| |
| import type { TLShapeId } from '@tldraw/tlschema' |
| import assert from 'node:assert/strict' |
| import { mkdtempSync, rmSync } from 'node:fs' |
| import { tmpdir } from 'node:os' |
| import { join } from 'node:path' |
| import { DatabaseSync } from 'node:sqlite' |
| import { after, test } from 'node:test' |
| import { paperShapeId } from '../shared/ids.ts' |
| import { defaultPaperCardProps } from '../shared/shapes.ts' |
| import { |
| addRemovedLink, |
| boardDb, |
| boardInfo, |
| boardsOf, |
| closeBoardDb, |
| createBoard, |
| DEFAULT_GOALS, |
| discardedIds, |
| ensureBoard, |
| findBoard, |
| joinMember, |
| markSeen, |
| membersOf, |
| papersOf, |
| removedLinks, |
| seedCount, |
| setBoardDbPath, |
| setDecision, |
| syncPapers, |
| touchRun, |
| unvotedCount, |
| updateBoard, |
| votesFor, |
| } from './boardDb.ts' |
| import { closeAllRooms, patchShapes, putShapes, readRoom, setRoomsDir, writeRoom, type ShapePatch } from './rooms.ts' |
|
|
| const dir = mkdtempSync(join(tmpdir(), 'board-db-')) |
| const dbFile = join(dir, 'board.db') |
| setRoomsDir(join(dir, 'rooms')) |
| setBoardDbPath(dbFile) |
| after(async () => { |
| |
| await new Promise((resolve) => setTimeout(resolve, 1100)) |
| closeAllRooms() |
| closeBoardDb() |
| rmSync(dir, { recursive: true, force: true }) |
| }) |
|
|
| const agentMeta = (paperId: string) => ({ createdBy: 'agent', onBehalfOf: 'm_ana', runId: 'run_0123456789ab', paperId }) |
| const card = (paperId: string, kind: 'seed' | 'kept' | 'suggestion' = 'suggestion', meta: object = agentMeta(paperId)) => ({ |
| id: paperShapeId(paperId), |
| type: 'paper-card', |
| x: 0, |
| y: 0, |
| props: defaultPaperCardProps(paperId, { title: paperId, kind }), |
| meta, |
| }) |
|
|
| test('migrates once, and keeps the data when it opens again', () => { |
| ensureBoard('kept-room') |
| closeBoardDb() |
| const raw = new DatabaseSync(dbFile) |
| assert.equal((raw.prepare('PRAGMA user_version').get() as { user_version: number }).user_version, 1) |
| raw.close() |
| assert.ok(findBoard('kept-room')) |
| assert.ok(boardDb().isOpen) |
| }) |
|
|
| test('a room gets its board row the first time it is used, with the default goals', () => { |
| assert.equal(findBoard('old-room'), null) |
| const board = ensureBoard('old-room') |
| assert.deepEqual({ ...board, createdAt: '' }, { |
| id: 'old-room', |
| title: '', |
| question: '', |
| context: '', |
| goals: DEFAULT_GOALS, |
| createdBy: null, |
| createdAt: '', |
| }) |
| assert.equal(ensureBoard('old-room').createdAt, board.createdAt) |
| |
| assert.equal(ensureBoard('odd room!').id, 'odd_room_') |
| }) |
|
|
| test('create and update a board; members join once, rename, and never move their seen mark back', () => { |
| const board = createBoard({ title: 'Melanoma', question: 'What predicts response?' }, 'm_ana') |
| assert.match(board.id, /^b_[a-z0-9]{10}$/) |
| assert.equal(board.createdBy, 'm_ana') |
| const updated = updateBoard(board.id, { context: 'Our cohort', title: undefined }) |
| assert.equal(updated.title, 'Melanoma') |
| assert.equal(updated.context, 'Our cohort') |
| assert.deepEqual(findBoard(board.id), updated) |
|
|
| assert.equal(joinMember(board.id, 'm_ben', 'Ben').joined, true) |
| const again = joinMember(board.id, 'm_ben') |
| assert.equal(again.joined, false) |
| assert.equal(again.member.displayName, 'Ben') |
| assert.equal(joinMember(board.id, 'm_ben', 'Benjamin').member.displayName, 'Benjamin') |
| assert.deepEqual(membersOf(board.id).map((m) => m.memberId), ['m_ben']) |
| markSeen(board.id, 'm_ben', 7) |
| markSeen(board.id, 'm_ben', 3) |
| assert.equal(membersOf(board.id)[0].lastSeenSeq, 7) |
|
|
| assert.ok(boardsOf('m_ana').some((b) => b.id === board.id), 'the creator') |
| assert.ok(boardsOf('m_ben').some((b) => b.id === board.id), 'a member') |
| assert.ok(!boardsOf('m_eve').some((b) => b.id === board.id)) |
| }) |
|
|
| test('decisions: one per member, in voting order; only-discarded papers are the negative signal', () => { |
| const b = 'votes' |
| assert.equal(setDecision(b, 'pmid:1', 'm_ana', 'keep'), null) |
| setDecision(b, 'pmid:1', 'm_ben', 'discard') |
| setDecision(b, 'pmid:2', 'm_ben', 'discard') |
| setDecision(b, 'pmid:3', 'm_ana', 'discard') |
| assert.equal(setDecision(b, 'pmid:3', 'm_ana', 'keep'), 'discard') |
| assert.deepEqual(votesFor(b, 'pmid:1'), { keepBy: ['m_ana'], discardBy: ['m_ben'] }) |
| assert.deepEqual(discardedIds(b), ['pmid:2']) |
| assert.equal(setDecision(b, 'pmid:2', 'm_ben', null), 'discard') |
| assert.deepEqual(discardedIds(b), []) |
| assert.deepEqual(votesFor(b, 'pmid:2'), { keepBy: [], discardBy: [] }) |
| }) |
|
|
| test('board_papers follows the cards: added, updated, dropped when the card goes', () => { |
| const b = 'mirror' |
| putShapes(b, [card('pmid:1', 'seed'), card('pmid:2'), card('pmid:3', 'suggestion', { author: 'm_ben' })]) |
| syncPapers(b) |
| const rows = papersOf(b) |
| assert.deepEqual(rows.map((r) => [r.paperId, r.kind, r.addedBy]), [ |
| ['pmid:1', 'seed', 'agent'], |
| ['pmid:2', 'suggestion', 'agent'], |
| ['pmid:3', 'suggestion', 'm_ben'], |
| ]) |
| assert.equal(rows[0].runId, 'run_0123456789ab') |
| assert.equal(seedCount(b), 1) |
| setDecision(b, 'pmid:2', 'm_ana', 'keep') |
| assert.equal(unvotedCount(b, 'm_ana'), 1) |
| assert.equal(unvotedCount(b, 'm_ben'), 2) |
|
|
| const scores = { methods: { score: 0.8, fit: 'high' as const, why: 'Same assay' } } |
| patchShapes(b, [{ id: paperShapeId('pmid:2') as TLShapeId, props: { status: 'kept', kind: 'kept', scores } } as ShapePatch]) |
| writeRoom(b, (txn) => txn.delete(paperShapeId('pmid:3') as TLShapeId)) |
| syncPapers(b) |
| assert.deepEqual(papersOf(b).map((r) => r.paperId), ['pmid:1', 'pmid:2']) |
| assert.deepEqual(papersOf(b)[1], { ...rows[1], kind: 'kept', status: 'kept', scores }) |
| assert.ok(readRoom(b, (txn) => txn.get(paperShapeId('pmid:1'))), 'syncing never writes to the room') |
| }) |
|
|
| test('removed links are recorded once; boardInfo has the question, goal IDs, discards and removed links', () => { |
| const b = 'info' |
| updateBoard(b, { question: 'Which T cells respond?', goals: [{ id: 'methods', label: 'Methods to reuse' }] }) |
| assert.equal(addRemovedLink(b, { from: 'pmid:1', to: 'pmid:2', kind: 'cites' }, 'm_ana'), true) |
| assert.equal(addRemovedLink(b, { from: 'pmid:1', to: 'pmid:2', kind: 'cites' }, 'm_ben'), false) |
| setDecision(b, 'pmid:9', 'm_ana', 'discard') |
| assert.deepEqual(removedLinks(b), [{ from: 'pmid:1', to: 'pmid:2', kind: 'cites' }]) |
| assert.deepEqual(boardInfo(b), { |
| question: 'Which T cells respond?', |
| goals: ['methods'], |
| discardedIds: ['pmid:9'], |
| removedLinks: [{ from: 'pmid:1', to: 'pmid:2', kind: 'cites' }], |
| }) |
| assert.deepEqual(boardInfo('never-used').goals, ['new-findings', 'methods']) |
| }) |
|
|
| test('runs count their canvas writes', () => { |
| touchRun('runs', 'run_00112233aabb', 'm_ana') |
| touchRun('runs', 'run_00112233aabb', 'm_ana') |
| const row = boardDb().prepare('SELECT * FROM runs WHERE id = ?').get('run_00112233aabb') as Record<string, unknown> |
| assert.equal(row.events, 2) |
| assert.equal(row.requested_by, 'm_ana') |
| assert.equal(row.board_id, 'runs') |
| }) |
|
|
