AI-native design editor. Open-source Figma alternative.
import { describe, expect, test } from 'bun:test'
import type * as Y from 'yjs'
import { claimRoot } from '@open-pencil/collab'
import { SceneGraph } from '@open-pencil/scene-graph'
import { openRoomSession, type RoomSession, type RoomSessionOptions } from '@/app/collab/session'
import { createEditorStore, type EditorStore } from '@/app/editor/session'
import { presenceOf } from '@/app/presence/registry'
import { expectDefined, getNodeOrThrow } from '#tests/helpers/assert'
import { createMemoryRooms } from '#tests/helpers/collab/memory-transport'
const ROOM_A = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
const ROOM_B = 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb'
const noSavedCopy = () => ({ whenSynced: Promise.resolve(), destroy: () => undefined })
async function withRooms(
run: (
open: (options: Omit<RoomSessionOptions, 'joinRoom'>) => RoomSession,
settle: () => Promise<void>
) => Promise<void>
) {
const rooms = createMemoryRooms()
const sessions: RoomSession[] = []
const stores: EditorStore[] = []
try {
await run((options) => {
stores.push(options.store)
const session = openRoomSession({
openSavedCopy: noSavedCopy,
...options,
joinRoom: rooms.join
})
sessions.push(session)
return session
}, rooms.settle)
} finally {
for (const session of sessions) session.dispose()
for (const store of stores) store.preparationController.dispose()
}
}
function newStore(name = 'Untitled') {
const store = createEditorStore(new SceneGraph())
store.state.documentName = name
return store
}
function firstPageId(store: EditorStore) {
return expectDefined(store.graph.getPages()[0], 'first page').id
}
describe('room sessions', () => {
test('renames reach the saver and count as edits without echoing back', async () => {
await withRooms(async (open, settle) => {
const host = newStore('Checkout')
const shared = open({ roomId: ROOM_A, store: host, origin: 'shared' })
shared.shareDocument()
const guest = newStore()
const joined = open({ roomId: ROOM_A, store: guest, origin: 'joined' })
await settle()
shared.saves.markSaved(shared.saves.counts())
await settle()
expect(joined.saves.unsaved()).toBe(false)
guest.renameDocument('Payment')
await settle()
expect(host.state.documentName).toBe('Payment')
expect(shared.saves.unsaved()).toBe(true)
const counts = shared.saves.counts()
await settle()
expect(shared.saves.counts()).toEqual(counts)
host.renameDocument('Receipt')
await settle()
expect(guest.state.documentName).toBe('Receipt')
})
})
test('a name the document takes without a rename stays out of the room', async () => {
await withRooms(async (open, settle) => {
const host = newStore('Checkout')
open({ roomId: ROOM_A, store: host, origin: 'shared' }).shareDocument()
const guest = newStore()
open({ roomId: ROOM_A, store: guest, origin: 'joined' })
await settle()
// As a save to a new place does while it writes, and undoes when the write fails.
host.state.documentName = 'Checkout copy'
await settle()
expect(guest.state.documentName).toBe('Checkout')
})
})
test("a joined tab shows the sharer's document, with its name, once it arrives", async () => {
await withRooms(async (open, settle) => {
const host = newStore('Checkout flow')
host.graph.createNode('RECTANGLE', firstPageId(host), { id: 'host:1', name: 'Card' })
const shared = open({ roomId: ROOM_A, store: host, origin: 'shared' })
shared.shareDocument()
const guest = newStore('Shared file')
const joined = open({ roomId: ROOM_A, store: guest, origin: 'joined' })
expect(joined.status.value).toBe('connecting')
await settle()
expect(joined.status.value).toBe('live')
expect(shared.status.value).toBe('live')
expect(guest.graph.rootId).toBe(host.graph.rootId)
expect(getNodeOrThrow(guest.graph, 'host:1').name).toBe('Card')
expect(guest.state.documentName).toBe('Checkout flow')
})
})
test('a room nobody with the document is in waits, then opens when the sharer comes', async () => {
await withRooms(async (open, settle) => {
const guest = newStore()
const joined = open({ roomId: ROOM_A, store: guest, origin: 'joined' })
await settle()
expect(joined.status.value).toBe('waiting')
expect(joined.hasDocument.value).toBe(false)
const host = newStore('Late')
open({ roomId: ROOM_A, store: host, origin: 'shared' }).shareDocument()
await settle()
expect(joined.status.value).toBe('live')
expect(guest.graph.rootId).toBe(host.graph.rootId)
})
})
test('two rooms in two tabs stay apart: edits and cursors reach only their own room', async () => {
await withRooms(async (open, settle) => {
const hostA = newStore('A')
const hostB = newStore('B')
const roomA = open({ roomId: ROOM_A, store: hostA, origin: 'shared' })
const roomB = open({ roomId: ROOM_B, store: hostB, origin: 'shared' })
roomA.shareDocument()
roomB.shareDocument()
const guestA = newStore()
const guestB = newStore()
const joinedA = open({ roomId: ROOM_A, store: guestA, origin: 'joined' })
const joinedB = open({ roomId: ROOM_B, store: guestB, origin: 'joined' })
await settle()
guestA.graph.createNode('RECTANGLE', firstPageId(guestA), { id: 'guest:a' })
joinedA.updateCursor(10, 20, firstPageId(guestA))
await settle()
expect(hostA.graph.getNode('guest:a')).toBeDefined()
expect(hostB.graph.getNode('guest:a')).toBeUndefined()
expect(guestB.graph.getNode('guest:a')).toBeUndefined()
expect(roomA.peers.value.map((peer) => peer.cursor?.x)).toEqual([10])
expect(roomB.peers.value.map((peer) => peer.cursor)).toEqual([undefined])
expect(joinedB.status.value).toBe('live')
})
})
test('an edit in a tab whose room has no document yet stays in that tab', async () => {
await withRooms(async (open, settle) => {
const guest = newStore()
open({ roomId: ROOM_A, store: guest, origin: 'joined' })
guest.graph.createNode('RECTANGLE', firstPageId(guest), { id: 'early' })
await settle()
const host = newStore()
open({ roomId: ROOM_A, store: host, origin: 'shared' }).shareDocument()
await settle()
expect(host.graph.getNode('early')).toBeUndefined()
})
})
test('peers say whether they have the file, so a newcomer knows whom it is waiting for', async () => {
await withRooms(async (open, settle) => {
const host = newStore('Shared')
open({ roomId: ROOM_A, store: host, origin: 'shared' }).shareDocument()
const early = open({ roomId: ROOM_B, store: newStore(), origin: 'joined' })
const other = open({ roomId: ROOM_B, store: newStore(), origin: 'joined' })
const guest = open({ roomId: ROOM_A, store: newStore(), origin: 'joined' })
await settle()
expect(guest.peers.value.map((peer) => peer.hasFile)).toEqual([true])
expect(early.peers.value.map((peer) => peer.hasFile)).toEqual([false])
expect(early.status.value).toBe('waiting')
expect(other.status.value).toBe('waiting')
})
})
test('a tab that holds the room’s document keeps showing it while its saved copy loads', async () => {
await withRooms(async (open) => {
let loaded: () => void = () => undefined
const whenSynced = new Promise<void>((resolve) => {
loaded = resolve
})
const session = open({
roomId: ROOM_A,
store: newStore('Poster'),
origin: 'shared',
holdsDocument: true,
openSavedCopy: () => ({ whenSynced, destroy: () => undefined })
})
expect(session.hasDocument.value).toBe(true)
expect(session.status.value).toBe('alone')
loaded()
})
})
test('a tab that holds the room’s document keeps showing it when the room’s root comes first', async () => {
await withRooms(async (open) => {
const room: { doc?: Y.Doc } = {}
const session = open({
roomId: ROOM_A,
store: newStore('Poster'),
origin: 'shared',
holdsDocument: true,
openSavedCopy: (_roomId, ydoc) => {
room.doc = ydoc
return noSavedCopy()
}
})
// The root another editor claimed, before any of its layers.
claimRoot(expectDefined(room.doc, 'room document').getMap('meta'), 'room:root')
expect(session.hasDocument.value).toBe(false)
expect(session.status.value).toBe('alone')
})
})
test('a room someone shared or joined can be left', async () => {
await withRooms(async (open) => {
const shared = open({ roomId: ROOM_A, store: newStore('Poster'), origin: 'shared' })
const joined = open({ roomId: ROOM_A, store: newStore(), origin: 'joined' })
expect([shared.leavable, joined.leavable]).toEqual([true, true])
})
})
test('a room a tab has left no longer changes that tab or its people', async () => {
await withRooms(async (open, settle) => {
const host = newStore('Shared')
const shared = open({ roomId: ROOM_A, store: host, origin: 'shared' })
shared.shareDocument()
const guest = newStore()
const joined = open({ roomId: ROOM_A, store: guest, origin: 'joined' })
await settle()
expect(joined.peers.value).toHaveLength(1)
joined.dispose()
host.graph.createNode('RECTANGLE', firstPageId(host), { id: 'after-leave' })
shared.updateCursor(10, 10, firstPageId(host))
await settle()
expect(guest.graph.getNode('after-leave')).toBeUndefined()
expect(joined.peers.value).toEqual([])
expect(presenceOf(guest).peers.value).toEqual([])
})
})
})