Files

79 lines
3.0 KiB
TypeScript

import { afterEach, expect, it, vi } from 'vitest'
import { loadLocalStepModel } from '../src/infrastructure/step-loader'
import type { StepWorkerResponse } from '../src/infrastructure/step-worker-protocol'
class ParserWorker {
static instances: ParserWorker[] = []
onmessage?: (event: { data: StepWorkerResponse }) => void
onerror?: (event: { preventDefault: () => void }) => void
onmessageerror?: () => void
terminate = vi.fn()
postMessage = vi.fn()
constructor() {
ParserWorker.instances.push(this)
}
reply(data: StepWorkerResponse) {
this.onmessage?.({ data })
}
}
afterEach(() => {
ParserWorker.instances = []
vi.unstubAllGlobals()
})
async function start(signal?: AbortSignal) {
vi.stubGlobal('Worker', ParserWorker)
const file = new File(['original STEP bytes'], 'part.step')
const promise = loadLocalStepModel(file, signal)
await vi.waitFor(() => expect(ParserWorker.instances).toHaveLength(1))
return { promise, file, worker: ParserWorker.instances[0] }
}
it('keeps parsing pending off the main thread, builds transferred geometry and preserves the file', async () => {
const { promise, file, worker } = await start()
const [request, transfer] = worker.postMessage.mock.calls[0]
expect(request.wasmUrl).toMatch(/\/vendor\/occt-import-js\/occt-import-js.wasm$/)
expect(transfer).toEqual([request.bytes])
expect(new TextDecoder().decode(request.bytes)).toBe('original STEP bytes')
worker.reply({
success: true,
faceCount: 1,
meshes: [
{
positions: new Float32Array([0, 0, 0, 1, 0, 0, 0, 1, 0]),
normals: new Float32Array([0, 0, 1, 0, 0, 1, 0, 0, 1]),
indices: new Uint32Array([0, 1, 2]),
},
],
})
const loaded = await promise
expect(loaded.faceCount).toBe(1)
expect(loaded.root.children).toHaveLength(1)
expect(worker.terminate).toHaveBeenCalledOnce()
expect(await file.text()).toBe('original STEP bytes')
loaded.dispose()
expect(loaded.root.children).toHaveLength(0)
})
it('terminates a running parser when the editor leaves or replaces the STEP file', async () => {
const controller = new AbortController()
const { promise, worker } = await start(controller.signal)
const rejection = expect(promise).rejects.toMatchObject({ name: 'AbortError' })
controller.abort()
await rejection
expect(worker.terminate).toHaveBeenCalledOnce()
})
it('returns parser failures and releases the worker so another import can succeed', async () => {
const { promise, worker } = await start()
const rejection = expect(promise).rejects.toThrow('无法解析')
worker.reply({ success: false, error: '无法解析' })
await rejection
expect(worker.terminate).toHaveBeenCalledOnce()
})
it('does not launch a worker for an already cancelled file read', async () => {
vi.stubGlobal('Worker', ParserWorker)
const controller = new AbortController()
controller.abort()
await expect(
loadLocalStepModel(new File(['x'], 'x.step'), controller.signal),
).rejects.toMatchObject({ name: 'AbortError' })
expect(ParserWorker.instances).toHaveLength(0)
})