mirror of
https://github.com/djdevin/recflare.git
synced 2026-09-09 23:21:30 -07:00
Devin Zuczek
235 lines
8.2 KiB
TypeScript
235 lines
8.2 KiB
TypeScript
import { adminSecretsStore, env, SELF } from 'cloudflare:test'
|
||
import { beforeAll, beforeEach, expect, it } from 'vitest'
|
||
|
||
import { ROOM_COMMENT_SCHEMA_DDL } from '@repo/domain'
|
||
|
||
import type { Env } from '../../context'
|
||
|
||
declare module 'cloudflare:test' {
|
||
interface ProvidedEnv extends Env {}
|
||
}
|
||
|
||
const ORIGIN = 'https://example.com'
|
||
|
||
beforeAll(async () => {
|
||
// Seed the shared JWT signing key into the local Secrets Store so .get() resolves.
|
||
await adminSecretsStore(env.JWT_SECRET).create('test-signing-key')
|
||
|
||
for (const stmt of ROOM_COMMENT_SCHEMA_DDL) await env.DB.prepare(stmt).run()
|
||
})
|
||
|
||
beforeEach(async () => {
|
||
// Ids are the read cursor, so each test starts from a clean, predictable sequence.
|
||
await env.DB.prepare('DELETE FROM room_comment').run()
|
||
await env.DB.prepare(`DELETE FROM sqlite_sequence WHERE name = 'room_comment'`).run()
|
||
})
|
||
|
||
// Mint a token the way the `auth` worker does, signing with the shared test key seeded
|
||
// into the JWT_SECRET store.
|
||
const TEST_SECRET = 'test-signing-key'
|
||
|
||
function b64url(input: ArrayBuffer | string): string {
|
||
const bytes = typeof input === 'string' ? new TextEncoder().encode(input) : new Uint8Array(input)
|
||
let binary = ''
|
||
for (const byte of bytes) binary += String.fromCharCode(byte)
|
||
return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
|
||
}
|
||
|
||
async function bearer(sub = '205'): Promise<Record<string, string>> {
|
||
const now = Math.floor(Date.now() / 1000)
|
||
const signingInput = `${b64url(JSON.stringify({ alg: 'HS256', typ: 'JWT' }))}.${b64url(
|
||
JSON.stringify({ sub, exp: now + 3600 })
|
||
)}`
|
||
const key = await crypto.subtle.importKey(
|
||
'raw',
|
||
new TextEncoder().encode(TEST_SECRET),
|
||
{ name: 'HMAC', hash: 'SHA-256' },
|
||
false,
|
||
['sign']
|
||
)
|
||
const sig = await crypto.subtle.sign('HMAC', key, new TextEncoder().encode(signingInput))
|
||
return { Authorization: `Bearer ${signingInput}.${b64url(sig)}` }
|
||
}
|
||
|
||
/** Post a comment the way the client does — form-encoded, positions as float text. */
|
||
async function postComment(
|
||
roomId: number,
|
||
fields: Record<string, string>,
|
||
sub = '205'
|
||
): Promise<Response> {
|
||
return SELF.fetch(`${ORIGIN}/comments/create/${roomId}`, {
|
||
method: 'POST',
|
||
headers: {
|
||
...(await bearer(sub)),
|
||
'content-type': 'application/x-www-form-urlencoded',
|
||
},
|
||
body: new URLSearchParams(fields).toString(),
|
||
})
|
||
}
|
||
|
||
it('answers the health check', async () => {
|
||
const res = await SELF.fetch(ORIGIN)
|
||
expect(res.status).toBe(200)
|
||
expect(await res.json()).toEqual({ service: 'roomcomments', status: 'ok' })
|
||
})
|
||
|
||
it('creates a comment and answers it as the client reads it', async () => {
|
||
const res = await postComment(1162, {
|
||
message: 'nice room',
|
||
subRoomId: '1296',
|
||
style: '0',
|
||
positionX: '1.5',
|
||
positionY: '0.0',
|
||
positionZ: '-3.25',
|
||
})
|
||
expect(res.status).toBe(200)
|
||
|
||
const comment = (await res.json()) as Record<string, unknown>
|
||
expect(comment).toEqual({
|
||
CommentId: 1,
|
||
RoomId: 1162,
|
||
SubRoomId: 1296,
|
||
AccountId: 205,
|
||
CreatedAt: expect.stringMatching(/^\d{4}-\d{2}-\d{2}T/),
|
||
Message: 'nice room',
|
||
Style: 0,
|
||
// True even here, on the author's own brand-new comment — it is read state, and
|
||
// nothing marks a comment read.
|
||
Unread: true,
|
||
PositionX: 1.5,
|
||
PositionY: 0,
|
||
PositionZ: -3.25,
|
||
})
|
||
})
|
||
|
||
it('round-trips a C# float’s text as a number', async () => {
|
||
// The digits the client actually posts: a float's shortest round-trip form. They go into
|
||
// a REAL column and have to come back out identical, and as numbers — a quoted float
|
||
// fails the client's parser.
|
||
const res = await postComment(1162, {
|
||
message: 'over here',
|
||
subRoomId: '1307',
|
||
style: '0',
|
||
positionX: '-0.4979804',
|
||
positionY: '1.568297',
|
||
positionZ: '-0.05002981',
|
||
})
|
||
const comment = (await res.json()) as Record<string, unknown>
|
||
expect(comment.PositionX).toBe(-0.4979804)
|
||
expect(comment.PositionY).toBe(1.568297)
|
||
expect(comment.PositionZ).toBe(-0.05002981)
|
||
})
|
||
|
||
it('serves a room’s comments newest first', async () => {
|
||
await postComment(1162, { message: 'first', subRoomId: '1296' })
|
||
await postComment(1162, { message: 'second', subRoomId: '1296' })
|
||
// A different room's comments never bleed into this one.
|
||
await postComment(99, { message: 'elsewhere', subRoomId: '1' })
|
||
|
||
const res = await SELF.fetch(`${ORIGIN}/comments/get/1162?count=100&minId=-1`)
|
||
expect(res.status).toBe(200)
|
||
const comments = (await res.json()) as Array<Record<string, unknown>>
|
||
expect(comments.map((x) => x.Message)).toEqual(['second', 'first'])
|
||
expect(comments.map((x) => x.CommentId)).toEqual([2, 1])
|
||
})
|
||
|
||
it('treats minId as an exclusive cursor', async () => {
|
||
await postComment(1162, { message: 'first', subRoomId: '1296' })
|
||
await postComment(1162, { message: 'second', subRoomId: '1296' })
|
||
await postComment(1162, { message: 'third', subRoomId: '1296' })
|
||
|
||
// A client holding up to id 1 polls for what was written since — not id 1 again.
|
||
const res = await SELF.fetch(`${ORIGIN}/comments/get/1162?count=100&minId=1`)
|
||
const comments = (await res.json()) as Array<Record<string, unknown>>
|
||
expect(comments.map((x) => x.CommentId)).toEqual([3, 2])
|
||
})
|
||
|
||
it('caps the page at count, keeping the newest', async () => {
|
||
for (const message of ['a', 'b', 'c']) {
|
||
await postComment(1162, { message, subRoomId: '1296' })
|
||
}
|
||
|
||
const res = await SELF.fetch(`${ORIGIN}/comments/get/1162?count=2&minId=-1`)
|
||
const comments = (await res.json()) as Array<Record<string, unknown>>
|
||
expect(comments.map((x) => x.Message)).toEqual(['c', 'b'])
|
||
})
|
||
|
||
it('narrows to one subroom when asked', async () => {
|
||
await postComment(1162, { message: 'in 1296', subRoomId: '1296' })
|
||
await postComment(1162, { message: 'in 1307', subRoomId: '1307' })
|
||
|
||
const res = await SELF.fetch(`${ORIGIN}/comments/get/1162?subRoomId=1307`)
|
||
const comments = (await res.json()) as Array<Record<string, unknown>>
|
||
expect(comments.map((x) => x.Message)).toEqual(['in 1307'])
|
||
})
|
||
|
||
it('marks every comment unread, the reader’s own included', async () => {
|
||
await postComment(1162, { message: 'mine', subRoomId: '1296' }, '205')
|
||
await postComment(1162, { message: 'theirs', subRoomId: '1296' }, '999')
|
||
|
||
const res = await SELF.fetch(`${ORIGIN}/comments/get/1162`, { headers: await bearer('205') })
|
||
const comments = (await res.json()) as Array<Record<string, unknown>>
|
||
expect(comments.map((x) => [x.Message, x.Unread])).toEqual([
|
||
['theirs', true],
|
||
['mine', true],
|
||
])
|
||
})
|
||
|
||
it('serves the read without a token at all', async () => {
|
||
await postComment(1162, { message: 'mine', subRoomId: '1296' }, '205')
|
||
|
||
const res = await SELF.fetch(`${ORIGIN}/comments/get/1162`)
|
||
expect(res.status).toBe(200)
|
||
const comments = (await res.json()) as Array<Record<string, unknown>>
|
||
expect(comments.map((x) => x.Unread)).toEqual([true])
|
||
})
|
||
|
||
it('has no comments for an unknown room — not a 404', async () => {
|
||
const res = await SELF.fetch(`${ORIGIN}/comments/get/424242?count=100&minId=-1`)
|
||
expect(res.status).toBe(200)
|
||
expect(await res.json()).toEqual([])
|
||
})
|
||
|
||
it('refuses an unauthenticated create', async () => {
|
||
const res = await SELF.fetch(`${ORIGIN}/comments/create/1162`, {
|
||
method: 'POST',
|
||
headers: { 'content-type': 'application/x-www-form-urlencoded' },
|
||
body: new URLSearchParams({ message: 'hi', subRoomId: '1296' }).toString(),
|
||
})
|
||
expect(res.status).toBe(401)
|
||
expect(await res.text()).toBe('')
|
||
})
|
||
|
||
it('refuses a blank message or a missing subroom', async () => {
|
||
expect((await postComment(1162, { message: ' ', subRoomId: '1296' })).status).toBe(400)
|
||
expect((await postComment(1162, { message: 'hi' })).status).toBe(400)
|
||
|
||
const res = await SELF.fetch(`${ORIGIN}/comments/get/1162`)
|
||
expect(await res.json()).toEqual([])
|
||
})
|
||
|
||
it('defaults an unparseable style and position to 0 rather than NaN', async () => {
|
||
const res = await postComment(1162, {
|
||
message: 'garbled',
|
||
subRoomId: '1296',
|
||
style: 'x',
|
||
positionX: 'NaN',
|
||
})
|
||
const comment = (await res.json()) as Record<string, unknown>
|
||
expect(comment.Style).toBe(0)
|
||
expect(comment.PositionX).toBe(0)
|
||
expect(comment.PositionY).toBe(0)
|
||
})
|
||
|
||
it('serves an openapi spec with no dangling refs', async () => {
|
||
const res = await SELF.fetch(`${ORIGIN}/openapi.json`)
|
||
expect(res.status).toBe(200)
|
||
const spec = (await res.json()) as Record<string, unknown>
|
||
expect(Object.keys(spec.paths as object).sort()).toEqual([
|
||
'/',
|
||
'/comments/create/{roomId}',
|
||
'/comments/get/{roomId}',
|
||
])
|
||
expect(JSON.stringify(spec).match(/\$ref/g)).toBeNull()
|
||
})
|