345 lines
13 KiB
TypeScript
345 lines
13 KiB
TypeScript
|
|
// The editor itself keeping what circuits hold: going into a component and
|
||
|
|
// back, reloading, other projects, and the account on other computers. It
|
||
|
|
// runs the real composable in a stand-in browser (storage, events, a server).
|
||
|
|
|
||
|
|
import * as vue from 'vue'
|
||
|
|
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
|
||
|
|
import { compile } from '../app/lib/logic/compile'
|
||
|
|
import { chipPins } from '../app/lib/logic/geometry'
|
||
|
|
import { createProject, lookup } from '../app/lib/logic/ops'
|
||
|
|
import { toProject } from '../app/lib/logic/project'
|
||
|
|
import { Simulator } from '../app/lib/logic/sim'
|
||
|
|
import { packState, stateCarry } from '../app/lib/logic/state'
|
||
|
|
import { listProjects, loadProject, saveProject, setCachedAccount, setCurrentId, type ProjectMeta } from '../app/lib/logic/storage'
|
||
|
|
import type { Project } from '../app/lib/logic/types'
|
||
|
|
|
||
|
|
const USER = { id: 'u1', email: 'me@example.com' }
|
||
|
|
|
||
|
|
/** An SR latch with two buttons, so its bit changes without any edit, open as the circuit. */
|
||
|
|
function latchProject(): Project {
|
||
|
|
const p = createProject({ examples: true })
|
||
|
|
const pins = chipPins(lookup(p)('ex-sr')!)
|
||
|
|
const pin = (label: string) => pins.inputs.find(x => x.label === label)!.key
|
||
|
|
p.components.push({
|
||
|
|
id: 'mem',
|
||
|
|
name: 'Memory',
|
||
|
|
symbol: 'box',
|
||
|
|
nodes: [
|
||
|
|
{ id: 's', kind: 'button', x: 0, y: 0, label: 'S' },
|
||
|
|
{ id: 'r', kind: 'button', x: 0, y: 4, label: 'R' },
|
||
|
|
{ id: 'u', kind: 'chip', chip: 'ex-sr', x: 6, y: 0 },
|
||
|
|
{ id: 'q', kind: 'output', x: 20, y: 0, label: 'Q' },
|
||
|
|
],
|
||
|
|
wires: [
|
||
|
|
{ id: 'w1', from: { node: 's', pin: 'q' }, to: { node: 'u', pin: pin('S') } },
|
||
|
|
{ id: 'w2', from: { node: 'r', pin: 'q' }, to: { node: 'u', pin: pin('R') } },
|
||
|
|
{ id: 'w3', from: { node: 'u', pin: pins.outputs[0]!.key }, to: { node: 'q', pin: 'a' } },
|
||
|
|
],
|
||
|
|
})
|
||
|
|
p.openId = 'mem'
|
||
|
|
return p
|
||
|
|
}
|
||
|
|
|
||
|
|
/** This browser's storage, kept across "reloads". */
|
||
|
|
let store: Map<string, string>
|
||
|
|
|
||
|
|
/** A tab with the editor open: the stand-in browser around it, then the real composable. */
|
||
|
|
async function openTab() {
|
||
|
|
const events = new Map<string, (() => void)[]>()
|
||
|
|
const on = (type: string, f: () => void) => events.set(type, [...(events.get(type) ?? []), f])
|
||
|
|
const doc = { addEventListener: on, visibilityState: 'visible' }
|
||
|
|
vi.stubGlobal('window', { addEventListener: on })
|
||
|
|
vi.stubGlobal('document', doc)
|
||
|
|
vi.stubGlobal('location', { pathname: '/', origin: 'http://localhost' })
|
||
|
|
vi.stubGlobal('history', { state: null, replaceState() {} })
|
||
|
|
for (const k of ['ref', 'computed', 'reactive', 'shallowRef', 'toRaw', 'watch'] as const) vi.stubGlobal(k, vue[k])
|
||
|
|
vi.resetModules()
|
||
|
|
const { useEditor } = await import('../app/composables/useEditor')
|
||
|
|
const ed = useEditor()
|
||
|
|
const fire = (type: string) => events.get(type)?.forEach(f => f())
|
||
|
|
return {
|
||
|
|
ed,
|
||
|
|
/** Q of the latch as the editor shows it. */
|
||
|
|
q: () => ed.val('q', 'a'),
|
||
|
|
/** A click on a button of the open circuit: down, settle, up, settle. */
|
||
|
|
push(label: string) {
|
||
|
|
const node = ed.def.value.nodes.find(n => n.label === label)!
|
||
|
|
ed.press(node, true)
|
||
|
|
ed.sim.value!.run()
|
||
|
|
ed.press(node, false)
|
||
|
|
ed.sim.value!.run()
|
||
|
|
},
|
||
|
|
hide() {
|
||
|
|
doc.visibilityState = 'hidden'
|
||
|
|
fire('visibilitychange')
|
||
|
|
},
|
||
|
|
close: () => fire('beforeunload'),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Puts a project in this browser's storage and makes it the one that opens. */
|
||
|
|
function stored(p: Project, meta: Partial<ProjectMeta> = {}): ProjectMeta {
|
||
|
|
const m: ProjectMeta = { id: 'p1', name: p.name, updated: Date.now(), ...meta }
|
||
|
|
saveProject(m, p)
|
||
|
|
setCurrentId(m.id)
|
||
|
|
return m
|
||
|
|
}
|
||
|
|
|
||
|
|
const copy = <T>(v: T): T => JSON.parse(JSON.stringify(v))
|
||
|
|
|
||
|
|
/** Q of the latch in a saved project, as it opens from what it held. */
|
||
|
|
function bitOf(p: Project): number {
|
||
|
|
const nl = compile(lookup(p), 'mem')
|
||
|
|
const held = p.state?.mem
|
||
|
|
const s = new Simulator(nl, held && stateCarry(held, nl))
|
||
|
|
s.run()
|
||
|
|
return s.pin('q', 'a')
|
||
|
|
}
|
||
|
|
|
||
|
|
/** The project after the latch was set on another computer. */
|
||
|
|
function setElsewhere(p: Project): Project {
|
||
|
|
const s = new Simulator(compile(lookup(p), 'mem'))
|
||
|
|
for (const [id, on] of [['s', true], ['s', false]] as const) {
|
||
|
|
s.setSource(id, on)
|
||
|
|
s.run()
|
||
|
|
}
|
||
|
|
p.state = { mem: packState(s)! }
|
||
|
|
return p
|
||
|
|
}
|
||
|
|
|
||
|
|
/** The account on the server, as far as syncing uses it: one save per project with its revision, and savegames. */
|
||
|
|
function account() {
|
||
|
|
const saves = new Map<string, { meta: { id: string; name: string; updated: number; rev: number }; project: Project }>()
|
||
|
|
const versions = new Map<string, { v: number; project: Project }[]>()
|
||
|
|
const keep = (id: string, project: Project) => {
|
||
|
|
const list = versions.get(id) ?? []
|
||
|
|
list.push({ v: Date.now() + list.length, project })
|
||
|
|
versions.set(id, list)
|
||
|
|
}
|
||
|
|
const put = (id: string, project: Project) => {
|
||
|
|
const old = saves.get(id)
|
||
|
|
if (old) keep(id, old.project)
|
||
|
|
const meta = { id, name: project.name, updated: Date.now(), rev: (old?.meta.rev ?? 0) + 1 }
|
||
|
|
saves.set(id, { meta, project: toProject(copy(project)) })
|
||
|
|
return meta
|
||
|
|
}
|
||
|
|
const route = (method: string, url: string, body: Record<string, unknown>): [number, unknown] => {
|
||
|
|
if (url === '/api/auth/me') return [200, { user: USER }]
|
||
|
|
if (url === '/api/auth/logout') return [200, {}]
|
||
|
|
if (url === '/api/me/projects') return [200, { projects: [...saves.values()].map(s => s.meta), deleted: [] }]
|
||
|
|
const [, id, rest] = url.match(/^\/api\/me\/projects\/([^/]+)(.*)$/) ?? []
|
||
|
|
if (!id) return [404, {}]
|
||
|
|
const save = saves.get(id)
|
||
|
|
if (rest === '' && method === 'GET') return save ? [200, { project: copy(save.project) }] : [404, {}]
|
||
|
|
if (rest === '' && method === 'PUT') {
|
||
|
|
if (save && save.meta.rev !== body.baseRev && body.force !== true) return [409, { conflict: true, meta: save.meta }]
|
||
|
|
return [200, { meta: put(id, body.project as Project) }]
|
||
|
|
}
|
||
|
|
if (rest === '/versions' && method === 'POST') return [200, keep(id, toProject(copy(body.project)))]
|
||
|
|
if (rest === '/versions') return [200, { versions: (versions.get(id) ?? []).map(x => ({ v: x.v, at: x.v, rev: 0, name: x.project.name, size: 0 })) }]
|
||
|
|
const v = versions.get(id)?.find(x => `/versions/${x.v}` === rest)
|
||
|
|
return v ? [200, { version: { project: copy(v.project) } }] : [404, {}]
|
||
|
|
}
|
||
|
|
vi.stubGlobal('fetch', async (url: string, init: { method?: string; body?: string } = {}) => {
|
||
|
|
const [status, data] = route(init.method ?? 'GET', url, init.body ? JSON.parse(init.body) : {})
|
||
|
|
return { ok: status < 400, status, json: async () => data }
|
||
|
|
})
|
||
|
|
setCachedAccount(USER)
|
||
|
|
return { saves, versions, put }
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Lets the timers due in `ms` run, and the requests they start finish. */
|
||
|
|
async function wait(ms: number) {
|
||
|
|
await vi.advanceTimersByTimeAsync(ms)
|
||
|
|
await new Promise(r => setImmediate(r))
|
||
|
|
}
|
||
|
|
|
||
|
|
beforeEach(() => {
|
||
|
|
store = new Map()
|
||
|
|
vi.stubGlobal('localStorage', {
|
||
|
|
getItem: (k: string) => store.get(k) ?? null,
|
||
|
|
setItem: (k: string, v: string) => void store.set(k, String(v)),
|
||
|
|
removeItem: (k: string) => void store.delete(k),
|
||
|
|
})
|
||
|
|
vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout', 'setInterval', 'clearInterval', 'Date'] })
|
||
|
|
})
|
||
|
|
|
||
|
|
afterEach(() => {
|
||
|
|
vi.useRealTimers()
|
||
|
|
vi.unstubAllGlobals()
|
||
|
|
})
|
||
|
|
|
||
|
|
describe('the editor keeping what circuits hold', () => {
|
||
|
|
it('keeps a bit set with buttons when you go into a component and come back, and after a reload', async () => {
|
||
|
|
stored(latchProject())
|
||
|
|
let tab = await openTab()
|
||
|
|
expect(tab.q()).toBe(0)
|
||
|
|
tab.push('S')
|
||
|
|
expect(tab.q()).toBe(1)
|
||
|
|
tab.ed.open('ex-sr')
|
||
|
|
tab.ed.back()
|
||
|
|
expect(tab.q()).toBe(1)
|
||
|
|
tab.ed.open('ex-sr')
|
||
|
|
tab.ed.goMain()
|
||
|
|
tab.ed.goTo(0)
|
||
|
|
tab.ed.open('mem')
|
||
|
|
expect(tab.q()).toBe(1)
|
||
|
|
tab.push('R')
|
||
|
|
tab.push('S')
|
||
|
|
tab.close()
|
||
|
|
tab = await openTab()
|
||
|
|
expect(tab.q()).toBe(1)
|
||
|
|
})
|
||
|
|
|
||
|
|
it('does not mix the bits of two projects with the same circuits', async () => {
|
||
|
|
const a = stored(latchProject())
|
||
|
|
const b = { ...a, id: 'p2', name: 'Other' }
|
||
|
|
saveProject(b, latchProject())
|
||
|
|
setCurrentId(a.id)
|
||
|
|
const tab = await openTab()
|
||
|
|
tab.push('S')
|
||
|
|
tab.ed.switchProject(b.id)
|
||
|
|
expect(tab.q()).toBe(0)
|
||
|
|
tab.ed.switchProject(a.id)
|
||
|
|
expect(tab.q()).toBe(1)
|
||
|
|
})
|
||
|
|
|
||
|
|
it('saves the bits of the circuit used last, and drops the oldest when there are too many', async () => {
|
||
|
|
const p = latchProject()
|
||
|
|
const filler = { names: [], on: 'x'.repeat(300_000) }
|
||
|
|
p.state = { main: filler, 'ex-sr': filler }
|
||
|
|
stored(p)
|
||
|
|
const tab = await openTab()
|
||
|
|
tab.push('S')
|
||
|
|
tab.ed.persist()
|
||
|
|
await wait(300)
|
||
|
|
const saved = loadProject('p1')!
|
||
|
|
expect(Object.keys(saved.state!)).toEqual(['ex-sr', 'mem'])
|
||
|
|
expect(bitOf(saved)).toBe(1)
|
||
|
|
})
|
||
|
|
|
||
|
|
it('says so once when a circuit holds more bits than a project keeps, and starts it from 0', async () => {
|
||
|
|
stored(latchProject())
|
||
|
|
const tab = await openTab()
|
||
|
|
// The editor's own limits: a room so small that one latch is already too much.
|
||
|
|
const { LIMITS } = await import('../app/lib/logic/project')
|
||
|
|
LIMITS.state = 10
|
||
|
|
tab.push('S')
|
||
|
|
tab.ed.open('ex-sr')
|
||
|
|
expect(tab.ed.notice.value).toEqual({ text: expect.stringContaining('too many bits'), kind: 'error' })
|
||
|
|
tab.ed.back()
|
||
|
|
expect(tab.q()).toBe(0)
|
||
|
|
tab.ed.notice.value = null
|
||
|
|
tab.push('S')
|
||
|
|
tab.ed.open('ex-sr')
|
||
|
|
tab.ed.back()
|
||
|
|
expect(tab.ed.notice.value).toBeNull()
|
||
|
|
})
|
||
|
|
|
||
|
|
it('takes the bits of a newer save from another computer, also for the circuit that is open', async () => {
|
||
|
|
const server = account()
|
||
|
|
// Here: revision 1, the latch at 0. The other computer saved revision 2 with the latch at 1.
|
||
|
|
stored(latchProject(), { cloud: { owner: USER.id, rev: 1 } })
|
||
|
|
server.put('p1', latchProject())
|
||
|
|
server.put('p1', setElsewhere(latchProject()))
|
||
|
|
const tab = await openTab()
|
||
|
|
expect(tab.q()).toBe(0)
|
||
|
|
await tab.ed.startAccount()
|
||
|
|
expect(tab.q()).toBe(1)
|
||
|
|
// The next save here keeps that 1 instead of writing this computer's old 0 over it.
|
||
|
|
await tab.ed.saveNow()
|
||
|
|
expect(server.saves.get('p1')!.meta.rev).toBe(3)
|
||
|
|
expect(bitOf(server.saves.get('p1')!.project)).toBe(1)
|
||
|
|
})
|
||
|
|
|
||
|
|
it('brings back the bits of a savegame, so Power off and on can be undone', async () => {
|
||
|
|
const server = account()
|
||
|
|
stored(latchProject())
|
||
|
|
const tab = await openTab()
|
||
|
|
await tab.ed.startAccount()
|
||
|
|
tab.push('S')
|
||
|
|
await tab.ed.saveNow()
|
||
|
|
tab.ed.resetState()
|
||
|
|
expect(tab.q()).toBe(0)
|
||
|
|
await tab.ed.saveNow()
|
||
|
|
expect(bitOf(server.saves.get('p1')!.project)).toBe(0)
|
||
|
|
const before = server.versions.get('p1')!.at(-1)!
|
||
|
|
expect(bitOf(before.project)).toBe(1)
|
||
|
|
await tab.ed.restoreVersion('p1', before.v, false)
|
||
|
|
expect(tab.q()).toBe(1)
|
||
|
|
})
|
||
|
|
|
||
|
|
it('sends bits set with buttons to the account when the page is left, not before', async () => {
|
||
|
|
const server = account()
|
||
|
|
stored(latchProject())
|
||
|
|
const tab = await openTab()
|
||
|
|
await tab.ed.startAccount()
|
||
|
|
tab.push('S')
|
||
|
|
// A running page writes the bits only to this browser.
|
||
|
|
await wait(61_000)
|
||
|
|
expect(bitOf(loadProject('p1')!)).toBe(1)
|
||
|
|
expect(server.saves.get('p1')!.meta.rev).toBe(1)
|
||
|
|
tab.hide()
|
||
|
|
await wait(2_000)
|
||
|
|
expect(server.saves.get('p1')!.meta.rev).toBe(2)
|
||
|
|
expect(bitOf(server.saves.get('p1')!.project)).toBe(1)
|
||
|
|
})
|
||
|
|
|
||
|
|
it('lets an edit saved on another computer win over bits changed here', async () => {
|
||
|
|
const server = account()
|
||
|
|
stored(latchProject())
|
||
|
|
const tab = await openTab()
|
||
|
|
await tab.ed.startAccount()
|
||
|
|
tab.push('S')
|
||
|
|
await wait(5_000)
|
||
|
|
const edited = latchProject()
|
||
|
|
edited.name = 'Edited elsewhere'
|
||
|
|
server.put('p1', edited)
|
||
|
|
tab.hide()
|
||
|
|
await wait(2_000)
|
||
|
|
expect(tab.ed.project.value.name).toBe('Edited elsewhere')
|
||
|
|
expect(server.saves.get('p1')!.project.name).toBe('Edited elsewhere')
|
||
|
|
// The bits of this computer are in the project's savegames.
|
||
|
|
expect(bitOf(server.versions.get('p1')!.at(-1)!.project)).toBe(1)
|
||
|
|
})
|
||
|
|
|
||
|
|
it('marks bits for the account when you leave the project, as no edit', async () => {
|
||
|
|
const a = stored(latchProject())
|
||
|
|
saveProject({ ...a, id: 'p2', name: 'Other' }, latchProject())
|
||
|
|
setCurrentId(a.id)
|
||
|
|
const tab = await openTab()
|
||
|
|
tab.push('S')
|
||
|
|
await wait(5_000)
|
||
|
|
tab.ed.switchProject('p2')
|
||
|
|
const left = listProjects().find(m => m.id === a.id)!
|
||
|
|
expect(left.dirty).toBe(true)
|
||
|
|
expect(left.updated).toBe(a.updated)
|
||
|
|
expect(bitOf(loadProject(a.id)!)).toBe(1)
|
||
|
|
})
|
||
|
|
|
||
|
|
it('keeps bits set with buttons when signing out and removing the projects from this browser', async () => {
|
||
|
|
const server = account()
|
||
|
|
stored(latchProject())
|
||
|
|
const tab = await openTab()
|
||
|
|
await tab.ed.startAccount()
|
||
|
|
tab.push('S')
|
||
|
|
await tab.ed.signOut(true)
|
||
|
|
expect(listProjects().some(m => m.id === 'p1')).toBe(false)
|
||
|
|
expect(bitOf(server.saves.get('p1')!.project)).toBe(1)
|
||
|
|
})
|
||
|
|
|
||
|
|
it('keeps the bits of the project it leaves when a savegame opens as a copy', async () => {
|
||
|
|
const server = account()
|
||
|
|
stored(latchProject())
|
||
|
|
const tab = await openTab()
|
||
|
|
await tab.ed.startAccount()
|
||
|
|
tab.push('S')
|
||
|
|
server.put('p9', createProject({ examples: false }))
|
||
|
|
server.put('p9', createProject({ examples: false }))
|
||
|
|
await tab.ed.restoreVersion('p9', server.versions.get('p9')![0]!.v, true)
|
||
|
|
expect(tab.ed.meta.value.id).not.toBe('p1')
|
||
|
|
expect(bitOf(loadProject('p1')!)).toBe(1)
|
||
|
|
})
|
||
|
|
})
|
||
|
|
|