Spaces:
Running
Running
| import assert from "node:assert/strict"; | |
| import { spawn } from "node:child_process"; | |
| import { once } from "node:events"; | |
| import { createServer, type IncomingHttpHeaders } from "node:http"; | |
| import type { AddressInfo } from "node:net"; | |
| import { test } from "node:test"; | |
| test("action chat sends measurements and annotated references on every message and preserves access checks", { timeout: 30_000 }, async () => { | |
| const owner = "11111111-1111-4111-8111-111111111111"; | |
| const other = "22222222-2222-4222-8222-222222222222"; | |
| const sessionId = "33333333-3333-4333-8333-333333333333"; | |
| const actionId = "44444444-4444-4444-8444-444444444444"; | |
| const otherActionId = "55555555-5555-4555-8555-555555555555"; | |
| const referenceSessionId = "77777777-7777-4777-8777-777777777777"; | |
| const foreignSessionId = "88888888-8888-4888-8888-888888888888"; | |
| const analytics = { foot_region: "Toe", active_foot_speed: 1232.04, standing_foot_contact_seconds: 0, | |
| ball_speed: 1303.31, touch_frame: 766, minimum_knee_angle: null, future_metric: false }; | |
| const measured = { id: actionId, label: "Pass", rawAnalytics: analytics, | |
| inActionMetrics: Object.entries(analytics).map(([name, value]) => ({ name, value, unit: name === "active_foot_speed" ? "cm/s" : "" })) }; | |
| const otherMeasured = { id: otherActionId, label: "Shoot", rawAnalytics: { ball_speed: 1303.31, active_foot_speed: 1232.04 }, | |
| inActionMetrics: [{ name: "Ball Speed", value: 1303.31, unit: "cm/s" }, { name: "Active Foot Speed", value: 1232.04, unit: "cm/s" }] }; | |
| let role = "user"; | |
| let sessionOwner = owner; | |
| let resultsAvailable = true; | |
| let analysisStatus = 200; | |
| let analysisReads = 0; | |
| let analysisHeaders: IncomingHttpHeaders = {}; | |
| let savedFeedbackAvailable = false; | |
| let referencesAvailable = true; | |
| let annotationsFail = false; | |
| let referenceResultsAvailable = true; | |
| let referenceReads = 0; | |
| let mutations = 0; | |
| const referenceAnalytics = { active_foot: "left", ball_speed: 1303.31, active_foot_speed: 1232.04, standing_foot_contact_seconds: 0, touch_frame: 999999 }; | |
| const offsets: Record<string, number> = { "00-blank": 0, "02-reference": 0, "00-foreign": 5, "03-reference": 300, | |
| "04-reference": 200, "05-reference": 100, "06-reference": 50, "07-reference": 20, "08-reference": 10, "zz-late": 1, "zz-wrong-report": 0 }; | |
| const referenceUsers = new Set<string>(); | |
| const reference = (id: string, type = "Pass", userId = owner, score: number | null = 7, notes = ["Reference coach note."]) => ({ | |
| action_id: id, score, annotations_notes: notes.map((note) => ({ note })), | |
| actions: { action_id: id, session_id: userId === owner ? referenceSessionId : foreignSessionId, type, | |
| sessions: { user_id: userId, players: { gender: "female", bdate: "2000-01-01", height: 170, weight: 65, position: "Forward" } } }, | |
| }); | |
| const examples = [reference(actionId), reference("00-foreign", "Pass", other, null), reference("shoot-reference", "Shoot"), | |
| reference("00-blank", "Pass", owner, null, [" "]), reference("01-empty"), reference("01-missing"), | |
| reference("02-reference", "Pass", owner, 0, []), reference("03-reference", "Pass", owner, null), | |
| ...Array.from({ length: 5 }, (_, index) => reference(`${String(index + 4).padStart(2, "0")}-reference`)), | |
| ...Array.from({ length: 110 }, (_, index) => reference(`far-${String(index).padStart(3, "0")}`)), | |
| reference("zz-late", "Pass", other, 0), reference("zz-no-common"), reference("zz-wrong-report")]; | |
| const referenceReport = (item: ReturnType<typeof reference>) => { | |
| const rawAnalytics: Record<string, unknown> = item.action_id === "01-empty" ? {} : item.action_id === "zz-no-common" ? { unrelated_metric: 42 } | |
| : { ...referenceAnalytics, active_foot_speed: referenceAnalytics.active_foot_speed + (offsets[item.action_id] ?? 500) }; | |
| return { id: item.action_id, label: item.action_id === "zz-wrong-report" ? "Shoot" : item.actions.type, rawAnalytics, | |
| inActionMetrics: Object.entries(rawAnalytics).map(([name, value]) => ({ name, value, unit: "" })) }; | |
| }; | |
| type Reference = { session_id: string; action_id: string; action_type: string; player: { gender: string }; score: number | null; notes: string[]; | |
| results: { metrics: unknown[]; analytics: unknown } }; | |
| type ChatPayload = { actions: unknown[]; message: string; history: unknown[]; | |
| context: { action?: { action_id: string; results: { metrics: unknown[]; analytics: unknown }; references: Reference[]; feedback: string[]; annotations: unknown }; actions?: unknown[] } }; | |
| const chats: ChatPayload[] = []; | |
| const generations: { actions: { action_id: string; references: Reference[] }[] }[] = []; | |
| let generationOverride: unknown; | |
| const upstream = createServer(async (req, res) => { | |
| const url = new URL(req.url!, "http://stub"); | |
| res.setHeader("Content-Type", "application/json"); | |
| if (url.pathname === "/auth/v1/user") return res.end(JSON.stringify({ id: owner, email: "test@example.com" })); | |
| if (url.pathname === `/api/sessions/${sessionId}`) { | |
| analysisReads++; | |
| analysisHeaders = req.headers; | |
| res.statusCode = analysisStatus; | |
| return res.end(JSON.stringify({ id: sessionId, actions: resultsAvailable ? [otherMeasured, measured] : [] })); | |
| } | |
| if ([`/api/sessions/${referenceSessionId}`, `/api/sessions/${foreignSessionId}`].includes(url.pathname)) { | |
| referenceReads++; | |
| const id = url.pathname.split("/").at(-1); | |
| const expectedOwner = id === referenceSessionId ? owner : other; | |
| referenceUsers.add(String(req.headers["x-sporalize-user-id"])); | |
| if (req.headers["x-sporalize-user-id"] !== expectedOwner) { | |
| res.statusCode = 403; | |
| return res.end("{}"); | |
| } | |
| res.statusCode = referenceResultsAvailable ? 200 : 503; | |
| return res.end(JSON.stringify({ id, actions: examples.filter((item) => item.action_id !== "01-missing" && item.actions.session_id === id).map(referenceReport) })); | |
| } | |
| if (url.pathname === "/api/chat") { | |
| let body = ""; | |
| for await (const chunk of req) body += chunk; | |
| chats.push(JSON.parse(body)); | |
| return res.end(JSON.stringify({ reply: "Measured coaching reply." })); | |
| } | |
| if (url.pathname === "/api/session/generate") { | |
| let body = ""; | |
| for await (const chunk of req) body += chunk; | |
| const input = JSON.parse(body); | |
| generations.push(input); | |
| return res.end(JSON.stringify(generationOverride ?? { actions: input.actions.map((action: { action_id: string }) => ({ action_id: action.action_id, feedback: ["Generated feedback."] })), session_feedback: ["Session summary."] })); | |
| } | |
| const table = url.pathname.split("/").at(-1); | |
| if (req.method !== "GET") { mutations++; return res.end("[]"); } | |
| if (table === "annotations" && annotationsFail) { | |
| res.statusCode = 400; | |
| return res.end(JSON.stringify({ message: "Annotations unavailable." })); | |
| } | |
| let rows: Record<string, unknown>[] = table === "users" ? [{ user_id: owner, account_role: role }] | |
| : table === "users_subscriptions" ? [{ user_id: owner, subscription_id: "plan", startdate: "2000-01-01", enddate: "2099-01-01", plan: { subscription_id: "plan" } }] | |
| : table === "sessions" ? [{ session_id: sessionId, user_id: sessionOwner, name: "Practice", players: { fname: "Player", gender: "male", bdate: "2000-01-01" } }] | |
| : table === "actions" ? [actionId, otherActionId].map((id) => ({ action_id: id, session_id: sessionId, type: id === actionId ? "Pass" : "Shoot", start_frame: 750, end_frame: 780, | |
| annotations: [{ score: 7, annotations_notes: [{ note: "Coach note." }] }] })) | |
| : table === "annotations" ? referencesAvailable ? examples : [] | |
| : table === "actions_feedbacks" ? savedFeedbackAvailable ? [{ action_id: actionId, feedback: "Saved action evaluation." }] : [] | |
| : table === "sessions_feedbacks" ? [{ session_id: sessionId, feedback: "Saved session evaluation." }] : []; | |
| const value = (row: Record<string, unknown>, key: string): unknown => key.split(".").reduce<unknown>((item, part) => (item as Record<string, unknown> | undefined)?.[part], row); | |
| for (const [key, filter] of url.searchParams) { | |
| if (filter.startsWith("eq.")) rows = rows.filter((row) => String(value(row, key)) === filter.slice(3)); | |
| if (filter.startsWith("neq.")) rows = rows.filter((row) => String(value(row, key)) !== filter.slice(4)); | |
| } | |
| if (url.searchParams.get("order") === "action_id.asc") rows = [...rows].sort((a, b) => String(a.action_id).localeCompare(String(b.action_id))); | |
| const from = Number(url.searchParams.get("offset") ?? 0); | |
| const limit = Number(url.searchParams.get("limit") ?? rows.length); | |
| res.end(JSON.stringify(rows.slice(from, from + limit))); | |
| }); | |
| upstream.listen(0, "127.0.0.1"); | |
| await once(upstream, "listening"); | |
| const upstreamOrigin = `http://127.0.0.1:${(upstream.address() as AddressInfo).port}`; | |
| const portProbe = createServer(); | |
| portProbe.listen(0, "127.0.0.1"); | |
| await once(portProbe, "listening"); | |
| const port = (portProbe.address() as AddressInfo).port; | |
| await new Promise<void>((resolve) => portProbe.close(() => resolve())); | |
| const origin = `http://127.0.0.1:${port}`; | |
| const child = spawn(process.execPath, ["--import", "tsx", "src/server.ts"], { | |
| env: { ...process.env, NODE_ENV: "test", PORT: String(port), FRONTEND_URL: origin, BACKEND_URL: origin, | |
| SUPABASE_URL: upstreamOrigin, SUPABASE_ANON_KEY: "test-anon", SUPABASE_SERVICE_ROLE_KEY: "test-service", | |
| ANALYSIS_API_URL: upstreamOrigin, ANALYSIS_PROXY_SECRET: "x".repeat(32), | |
| AGENT_API_URL: upstreamOrigin, AGENT_API_KEY: "a".repeat(32), HF_TOKEN: "" }, | |
| stdio: ["ignore", "pipe", "pipe"], | |
| }); | |
| try { | |
| let stderr = ""; | |
| child.stderr.on("data", (data) => { stderr += String(data); }); | |
| await new Promise<void>((resolve, reject) => { | |
| child.stdout.on("data", (data) => { if (String(data).includes("API listening")) resolve(); }); | |
| child.once("exit", (code) => reject(new Error(`API exited: ${code}\n${stderr}`))); | |
| child.once("error", reject); | |
| }); | |
| const request = (input: Record<string, unknown>, authenticated = true) => fetch(`${origin}/api/agent/chat`, { | |
| method: "POST", signal: AbortSignal.timeout(10000), | |
| headers: { "Content-Type": "application/json", Origin: origin, ...(authenticated ? { Cookie: "sp_access=access" } : {}) }, | |
| body: JSON.stringify({ message: "Explain these measurements.", ...input }), | |
| }); | |
| const selected = { sessionId, actionId }; | |
| assert.equal((await request(selected, false)).status, 401); | |
| assert.equal(analysisReads, 0); | |
| assert.equal((await request(selected)).status, 200); | |
| assert.equal(analysisReads, 1); | |
| assert.deepEqual(chats[0].context.action?.results, { metrics: measured.inActionMetrics, analytics }); | |
| assert.deepEqual(chats[0].context.action?.feedback, []); | |
| const expectedReferences = ["zz-late", "00-foreign", "08-reference", "07-reference", "06-reference"]; | |
| assert.deepEqual(chats[0].context.action?.references.map((item) => item.action_id), expectedReferences); | |
| assert.ok(chats[0].context.action?.references.every((item) => item.action_type === "Pass" && item.player.gender === "female")); | |
| const nearest = referenceReport(examples.find((item) => item.action_id === "zz-late")!); | |
| assert.deepEqual(chats[0].context.action?.references[0].results, { metrics: nearest.inActionMetrics, analytics: nearest.rawAnalytics }); | |
| assert.equal(chats[0].context.action?.references[0].session_id, foreignSessionId, "comparisons include other accounts with their real session IDs"); | |
| assert.equal(chats[0].context.action?.references[0].score, 0); | |
| assert.equal(chats[0].context.action?.references[1].score, null); | |
| assert.deepEqual(chats[0].context.action?.references[0].notes, ["Reference coach note."]); | |
| assert.equal(referenceReads, 2, "each session is fetched once across all candidate pages"); | |
| assert.deepEqual(referenceUsers, new Set([owner, other])); | |
| assert.deepEqual(chats[0].context.action?.annotations, [{ score: 7, annotations_notes: [{ note: "Coach note." }] }]); | |
| assert.equal(analysisHeaders["x-sporalize-user-id"], owner); | |
| assert.equal(analysisHeaders["x-sporalize-proxy-secret"], "x".repeat(32)); | |
| assert.equal(analysisHeaders["x-sporalize-admin"], undefined); | |
| analytics.ball_speed = 1500.123456; | |
| measured.inActionMetrics.find((metric) => metric.name === "ball_speed")!.value = analytics.ball_speed; | |
| savedFeedbackAvailable = true; | |
| referenceAnalytics.ball_speed = 1400.75; | |
| const history = [{ role: "user", content: "Explain these measurements." }, { role: "assistant", content: "Previous reply." }]; | |
| assert.equal((await request({ ...selected, message: "What changed?", history })).status, 200); | |
| assert.equal(analysisReads, 2); | |
| assert.deepEqual(chats[1].context.action?.results, { metrics: measured.inActionMetrics, analytics }); | |
| assert.deepEqual(chats[1].context.action?.feedback, ["Saved action evaluation."]); | |
| const updatedNearest = referenceReport(examples.find((item) => item.action_id === "zz-late")!); | |
| assert.deepEqual(chats[1].context.action?.references[0].results, { metrics: updatedNearest.inActionMetrics, analytics: updatedNearest.rawAnalytics }); | |
| assert.equal(referenceReads, 4, "each message gets current reference measurements"); | |
| assert.deepEqual(chats[1].history, history); | |
| assert.equal((await request({ sessionId, actionId: otherActionId })).status, 200); | |
| assert.deepEqual(chats[2].context.action?.results, { metrics: otherMeasured.inActionMetrics, analytics: otherMeasured.rawAnalytics }); | |
| assert.deepEqual(chats[2].context.action?.references.map((item) => item.action_id), ["shoot-reference"]); | |
| const chatCount = chats.length; | |
| const readCount = analysisReads; | |
| sessionOwner = other; | |
| assert.equal((await request(selected)).status, 404); | |
| assert.equal(analysisReads, readCount, "unauthorized requests must not load measurements"); | |
| assert.equal(chats.length, chatCount); | |
| role = "admin"; | |
| assert.equal((await request(selected)).status, 200); | |
| assert.equal(analysisHeaders["x-sporalize-admin"], "true"); | |
| assert.equal(analysisHeaders["x-sporalize-user-id"], owner); | |
| assert.deepEqual(chats.at(-1)?.context.action?.results, { metrics: measured.inActionMetrics, analytics }); | |
| role = "user"; | |
| sessionOwner = owner; | |
| referencesAvailable = false; | |
| assert.equal((await request(selected)).status, 200); | |
| assert.deepEqual(chats.at(-1)?.context.action?.references, []); | |
| referencesAvailable = true; | |
| referenceResultsAvailable = false; | |
| const readsBeforeMissing = referenceReads; | |
| assert.equal((await request(selected)).status, 200); | |
| assert.deepEqual(chats.at(-1)?.context.action?.references, []); | |
| assert.equal(referenceReads, readsBeforeMissing + 2, "unavailable reference results are not retried for each candidate page"); | |
| referenceResultsAvailable = true; | |
| const chatsBeforeFailure = chats.length; | |
| annotationsFail = true; | |
| assert.equal((await request(selected)).status, 500); | |
| assert.equal(chats.length, chatsBeforeFailure, "a DB failure must not be presented as an empty search"); | |
| annotationsFail = false; | |
| const successfulChats = chats.length; | |
| resultsAvailable = false; | |
| assert.equal((await request(selected)).status, 404); | |
| analysisStatus = 503; | |
| assert.equal((await request(selected)).status, 500); | |
| assert.equal(chats.length, successfulChats, "missing results must not produce an ungrounded reply"); | |
| const failedReads = analysisReads; | |
| assert.equal((await request({ actionId })).status, 400); | |
| assert.equal((await request({ ...selected, actionId: "66666666-6666-4666-8666-666666666666" })).status, 404); | |
| assert.equal(analysisReads, failedReads); | |
| assert.equal((await request({ sessionId })).status, 200); | |
| assert.equal((await request({})).status, 200); | |
| assert.equal(analysisReads, failedReads, "general and session chats do not need action measurements"); | |
| assert.equal(chats.at(-1)?.context.action, undefined); | |
| assert.equal(mutations, 0, "chat must not save or replace feedback"); | |
| analysisStatus = 200; | |
| resultsAvailable = true; | |
| Object.assign(process.env, { FRONTEND_URL: origin, BACKEND_URL: origin, SUPABASE_URL: upstreamOrigin, | |
| SUPABASE_ANON_KEY: "test-anon", SUPABASE_SERVICE_ROLE_KEY: "test-service", ANALYSIS_API_URL: upstreamOrigin, | |
| ANALYSIS_PROXY_SECRET: "x".repeat(32), AGENT_API_URL: upstreamOrigin, AGENT_API_KEY: "a".repeat(32), HF_TOKEN: "" }); | |
| const { createClient } = await import("@supabase/supabase-js"); | |
| const { actionDistance, generateSessionFeedback } = await import("../src/agent-session.js"); | |
| const sample = (rawAnalytics: Record<string, unknown>) => ({ id: "sample", label: "Pass", rawAnalytics }); | |
| assert.equal(actionDistance(sample({ speed: 0, touch_frame: 1 }), sample({ speed: 0, touch_frame: 9999 })), 0); | |
| assert.equal(actionDistance(sample({ missing: null, flag: false, region: "Toe" }), sample({ speed: 0 })), null); | |
| assert.equal(actionDistance(sample({ speed: 10 }), sample({ speed: "10" })), null); | |
| assert.equal(actionDistance(sample({ speed: 10 }), sample({ unrelated: 10 })), null); | |
| assert.ok(actionDistance(sample({ speed: 1000, angle: 100 }), sample({ speed: 1010, angle: 101 }))! | |
| < actionDistance(sample({ speed: 1000, angle: 100 }), sample({ speed: 1000 }))!, "missing values must not outrank complete close measurements"); | |
| assert.equal(actionDistance(sample({ ball_speed: 10, touch_frame: 1 }), sample({ ball_speed: 9999, touch_frame: 9999 })), null); | |
| assert.equal(actionDistance(sample({ active_foot_speed: 10, ball_speed: 10, touch_frame: 1 }), { id: "metric", label: "Pass", | |
| inActionMetrics: [{ name: "Active Foot Speed", value: 10 }, { name: "Ball Speed", value: 9999 }, { name: "Touch Frame", value: 9999 }] }), 0); | |
| const db = createClient(upstreamOrigin, "test-service", { auth: { persistSession: false } }); | |
| const readsBeforeGeneration = referenceReads; | |
| await generateSessionFeedback(db, sessionId, owner); | |
| assert.equal(referenceReads - readsBeforeGeneration, 2, "all actions in a generation share reference session downloads"); | |
| assert.deepEqual(generations[0].actions.find((item) => item.action_id === actionId)?.references.map((item) => item.action_id), expectedReferences); | |
| assert.deepEqual(generations[0].actions.find((item) => item.action_id === otherActionId)?.references.map((item) => item.action_id), ["shoot-reference"]); | |
| assert.equal(mutations, 6, "automatic generation still persists feedback for both actions and the session"); | |
| await generateSessionFeedback(db, sessionId, owner); | |
| assert.equal(referenceReads - readsBeforeGeneration, 4, "a new generation fetches fresh reference measurements"); | |
| const mutationsBeforeInvalid = mutations; | |
| for (const invalid of [ | |
| { actions: [{ action_id: "foreign-action", feedback: ["Bad."] }, { action_id: otherActionId, feedback: ["Good."] }], session_feedback: ["Summary."] }, | |
| { actions: [{ action_id: actionId, feedback: ["Bad."] }, { action_id: actionId, feedback: ["Duplicate."] }], session_feedback: ["Summary."] }, | |
| { actions: [{ action_id: actionId, feedback: ["Bad."] }], session_feedback: ["Summary."] }, | |
| { actions: [{ action_id: actionId, feedback: ["Bad."] }, { action_id: otherActionId, feedback: [" "] }], session_feedback: ["Summary."] }, | |
| ]) { | |
| generationOverride = invalid; | |
| await assert.rejects(generateSessionFeedback(db, sessionId, owner), /Agent generation failed/); | |
| assert.equal(mutations, mutationsBeforeInvalid, "invalid agent output cannot change stored feedback"); | |
| } | |
| generationOverride = undefined; | |
| } finally { | |
| if (child.exitCode === null && child.signalCode === null) { | |
| const exited = once(child, "exit"); | |
| child.kill(); | |
| await exited; | |
| } | |
| upstream.closeAllConnections(); | |
| await new Promise<void>((resolve) => upstream.close(() => resolve())); | |
| } | |
| }); | |