79 lines
3.0 KiB
TypeScript
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)
|
|
})
|