242 lines
11 KiB
TypeScript
242 lines
11 KiB
TypeScript
// @vitest-environment jsdom
|
|
/**
|
|
* The native tab registration LIFECYCLE (`src/client/native/index.ts`): what a
|
|
* store/service notification may do to the host's tab-type registry, and what
|
|
* a failed registration is allowed to leave behind.
|
|
*
|
|
* The failure this locks is a plugin RELOAD: cordis tears the fiber down, each
|
|
* built-in descriptor is unregistered one by one, every unregistration notifies
|
|
* the plugin's service, and `sync()` therefore runs again on a context that is
|
|
* already inactive. A registration attempted there throws
|
|
* (`ctx.effect` on an inactive context) — and if the host-side type was already
|
|
* registered at that point, its disposer is lost, the id stays taken for the
|
|
* rest of the page's life, and every later attempt is refused with
|
|
* `tab type id "…" is already registered`. The kind then renders the host's
|
|
* "nothing here can view this kind of content" face until a page refresh.
|
|
*
|
|
* Three properties keep that impossible, and all are asserted here:
|
|
* 1. an unrelated notification never re-creates the `files` takeover (the
|
|
* tear-down/re-register window the reload used to walk into);
|
|
* 2. a registration that fails after its type was registered releases the
|
|
* type again, so the id stays registrable and one broken descriptor cannot
|
|
* take the others down with it;
|
|
* 3. slots installed before the failing one are released too (the partial
|
|
* release inside `registerSlots`).
|
|
*
|
|
* The assertions are written against the fake registry's EVENT LOG, not only
|
|
* against the set of live ids: an orphaned type leaves the key set identical to
|
|
* a healthy one, so a key-set assertion would pass on the unfixed code and pin
|
|
* nothing.
|
|
*/
|
|
import { describe, expect, it, vi } from 'vitest'
|
|
import { registerNativeSurface } from '../src/client/native/index.ts'
|
|
import { createNativeTabRecords } from '../src/client/native/tab-adapter.tsx'
|
|
import { createBetterSidebarService } from '../src/client/service.ts'
|
|
import { createSidebarStore } from '../src/client/state.ts'
|
|
|
|
/**
|
|
* The fake `sidebarRightTabs`, mirroring the host's two hard rules: one
|
|
* registration per id, and the returned disposer is the only way to free it.
|
|
*/
|
|
function createRegistry() {
|
|
const registered = new Map<string, () => void>()
|
|
const events: string[] = []
|
|
let failReleaseOf: string | undefined
|
|
return {
|
|
registered,
|
|
events,
|
|
failRelease(id: string): void { failReleaseOf = id },
|
|
register(definition: { id: string }): () => void {
|
|
if (registered.has(definition.id)) {
|
|
throw new Error(`sidebarRight: tab type id "${definition.id}" is already registered`)
|
|
}
|
|
events.push(`register ${definition.id}`)
|
|
// The host's disposer is IDEMPOTENT (a cordis effect disposer returns
|
|
// the same task on a second call), so a repeated release must neither
|
|
// log again nor pretend to free something twice.
|
|
let released = false
|
|
const dispose = (): void => {
|
|
if (released) return
|
|
if (failReleaseOf === definition.id) throw new Error(`cannot release ${definition.id}`)
|
|
released = true
|
|
registered.delete(definition.id)
|
|
events.push(`release ${definition.id}`)
|
|
}
|
|
registered.set(definition.id, dispose)
|
|
return dispose
|
|
},
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A fake client context: `slots.inject` runs its callback synchronously (the
|
|
* real one resolves the declaration and calls `ctx.effect`, which throws while
|
|
* `inactive`), a slot listed in `failSlots` throws from `slots.register`, and
|
|
* `inject` hands back the registry while honouring the callback's own teardown.
|
|
*
|
|
* Slot failures are keyed by `name::key` — NOT by `key` alone. Both slots of a
|
|
* descriptor share the same key, so a key-keyed failure can only ever fail the
|
|
* FIRST slot; failing the second one for a single descriptor is the only shape
|
|
* that exercises `registerSlots`' partial release (the first slot is already
|
|
* installed when the second throws).
|
|
*/
|
|
function createHost() {
|
|
const registry = createRegistry()
|
|
/** Slot registrations and releases, in order (the partial-release witness). */
|
|
const slotEvents: string[] = []
|
|
// One mutable state object the ctx closures read: the test flips it after
|
|
// the host was built.
|
|
const state = {
|
|
/** True while the plugin's context is being torn down (the reload case). */
|
|
inactive: false,
|
|
/** `name::key` slots whose registration throws. */
|
|
failSlots: new Set<string>(),
|
|
}
|
|
const slotId = (options: { name: string; key?: string }): string => `${options.name}::${options.key ?? ''}`
|
|
const ctx = {
|
|
inject: (
|
|
_deps: readonly string[],
|
|
callback: (injected: { get: (name: string) => unknown }) => (() => void) | void,
|
|
) => {
|
|
const teardown = callback({ get: () => registry })
|
|
return { dispose: () => { if (typeof teardown === 'function') teardown() } }
|
|
},
|
|
get: () => registry,
|
|
slots: {
|
|
inject: (_name: string, callback: () => Array<() => void> | (() => void)) => {
|
|
if (state.inactive) throw new Error('cannot create effect on inactive context')
|
|
return typeof callback === 'function' ? callback() : () => {}
|
|
},
|
|
register: (options: { name: string; key?: string }) => {
|
|
const id = slotId(options)
|
|
if (state.failSlots.has(id)) throw new Error(`slot registration for "${id}" failed`)
|
|
slotEvents.push(`register ${id}`)
|
|
return () => { slotEvents.push(`release ${id}`) }
|
|
},
|
|
},
|
|
}
|
|
return { registry, slotEvents, state, ctx }
|
|
}
|
|
|
|
/** A store + service with two enabled descriptors, plus the record registry. */
|
|
function createPlugins() {
|
|
const store = createSidebarStore()
|
|
store.setSession('s1')
|
|
const service = createBetterSidebarService(store)
|
|
service.registerTab({ id: 'editor', title: 'Files', component: () => null, icon: () => null })
|
|
service.registerTab({ id: 'git', title: 'Changes', component: () => null })
|
|
return { store, service, records: createNativeTabRecords() }
|
|
}
|
|
|
|
/** Silence (and count) the failure logs the fixed code reports on purpose. */
|
|
function silenceFailures(): { restore: () => void; messages: string[] } {
|
|
const messages: string[] = []
|
|
const spy = vi.spyOn(console, 'error').mockImplementation((...args: unknown[]) => {
|
|
messages.push(args.map(String).join(' '))
|
|
})
|
|
return { restore: () => { spy.mockRestore() }, messages }
|
|
}
|
|
|
|
/**
|
|
* The phase labels a surface reports through the client's visible diagnostic
|
|
* channel (`reportFailure` → `fail('native ' + phase, error)`).
|
|
*/
|
|
function collectReports(): { phases: string[]; report: (phase: string) => void } {
|
|
const phases: string[] = []
|
|
return { phases, report: (phase: string) => { phases.push(phase) } }
|
|
}
|
|
|
|
describe('native tab registration lifecycle', () => {
|
|
it('releases a type whose slot registration failed, and can register it again later', () => {
|
|
const host = createHost()
|
|
const { store, service, records } = createPlugins()
|
|
const reports = collectReports()
|
|
// The reload: the context goes inactive while notifications are still
|
|
// arriving, so every slot registration fails after its type registered.
|
|
host.state.inactive = true
|
|
expect(() => registerNativeSurface({
|
|
ctx: host.ctx as never, store, service, records, reportFailure: reports.report,
|
|
})).not.toThrow()
|
|
expect([...host.registry.registered.keys()], 'a failed registration leaves no type behind').toEqual([])
|
|
// Each of them is reported through the visible channel, not swallowed.
|
|
expect(reports.phases.sort()).toEqual(['register editor', 'register files', 'register git'])
|
|
|
|
// The context comes back (the reload's next activation): the same ids must
|
|
// be registrable — no "already registered" from the orphan. The event log
|
|
// is the discriminating assertion: a leaked type would keep the key set
|
|
// looking correct while the retry throws into the same catch.
|
|
host.state.inactive = false
|
|
host.registry.events.length = 0
|
|
store.setPrefs(store.getPrefs())
|
|
expect(host.registry.events.sort()).toEqual([
|
|
'register dsh-apes-sidebar:editor',
|
|
'register dsh-apes-sidebar:files',
|
|
'register dsh-apes-sidebar:git',
|
|
])
|
|
})
|
|
|
|
it('never re-creates the "files" takeover on an unrelated notification', () => {
|
|
const host = createHost()
|
|
const { store, service, records } = createPlugins()
|
|
const dispose = registerNativeSurface({ ctx: host.ctx as never, store, service, records })
|
|
// The takeover is this module's own entry (never a descriptor), so no
|
|
// store/service notification has any business touching it. Before the fix
|
|
// every notification disposed and re-created it.
|
|
host.registry.events.length = 0
|
|
for (let round = 0; round < 3; round++) store.setPrefs(store.getPrefs())
|
|
expect(host.registry.events, 'no notification may tear the "files" takeover down').toEqual([])
|
|
expect(host.registry.registered.has('dsh-apes-sidebar:files')).toBe(true)
|
|
dispose()
|
|
})
|
|
|
|
it('keeps the other tab types when one descriptor cannot register', () => {
|
|
const host = createHost()
|
|
const { store, service, records } = createPlugins()
|
|
const reports = collectReports()
|
|
// The SECOND slot of ONE descriptor: its type and its body slot are
|
|
// already installed when this one throws.
|
|
host.state.failSlots.add('sidebar.right.pane.tab.title::dsh-apes-sidebar:git')
|
|
const log = silenceFailures()
|
|
try {
|
|
expect(() => registerNativeSurface({
|
|
ctx: host.ctx as never, store, service, records, reportFailure: reports.report,
|
|
})).not.toThrow()
|
|
expect([...host.registry.registered.keys()].sort()).toEqual([
|
|
'dsh-apes-sidebar:editor',
|
|
'dsh-apes-sidebar:files',
|
|
])
|
|
expect(reports.phases).toEqual(['register git'])
|
|
// The body slot installed before the failure was released; the failing
|
|
// one never registered, so there is nothing to release for it.
|
|
expect(host.slotEvents.filter(event => event === 'release sidebar.right.pane.tab::dsh-apes-sidebar:git'))
|
|
.toHaveLength(1)
|
|
expect(host.slotEvents.filter(event => event === 'release sidebar.right.pane.tab.title::dsh-apes-sidebar:git'))
|
|
.toEqual([])
|
|
|
|
// The broken descriptor is retried on the next sync instead of being
|
|
// written off — and the retry REGISTERS it (event log), rather than
|
|
// merely ending up with a key set a leaked type produces as well.
|
|
host.state.failSlots.clear()
|
|
host.registry.events.length = 0
|
|
store.setPrefs(store.getPrefs())
|
|
expect(host.registry.events).toEqual(['register dsh-apes-sidebar:git'])
|
|
} finally {
|
|
log.restore()
|
|
}
|
|
})
|
|
|
|
it('releases every registration on teardown even when one release throws', () => {
|
|
const host = createHost()
|
|
const { store, service, records } = createPlugins()
|
|
const log = silenceFailures()
|
|
try {
|
|
const dispose = registerNativeSurface({ ctx: host.ctx as never, store, service, records })
|
|
host.registry.failRelease('dsh-apes-sidebar:editor')
|
|
expect(() => dispose()).not.toThrow()
|
|
expect([...host.registry.registered.keys()]).toEqual(['dsh-apes-sidebar:editor'])
|
|
} finally {
|
|
log.restore()
|
|
}
|
|
})
|
|
})
|