|
1 | 1 | import assert from 'node:assert/strict' |
2 | 2 | import { readFile } from 'node:fs/promises' |
3 | 3 | import path from 'node:path' |
4 | | -import test from 'node:test' |
5 | | -import { pathToFileURL } from 'node:url' |
6 | | -import { createRequire } from 'node:module' |
7 | 4 | import { EdgeRuntime } from 'edge-runtime' |
8 | 5 |
|
9 | | -const distEntryPath = path.resolve('dist/index.cjs') |
10 | | -const distEntryUrl = pathToFileURL(distEntryPath) |
| 6 | +const distEntryPath = path.resolve('dist/index.js') |
11 | 7 | const distSource = await readFile(distEntryPath, 'utf8') |
12 | | -const nodeRequire = createRequire(distEntryUrl) |
13 | | - |
14 | | -test('edge runtime uses the wasm-only inference path and reports no GPU acceleration', async () => { |
15 | | - let usedWasmRuntime = false |
16 | | - let usedBrowserRuntime = false |
17 | | - let executionProviders |
18 | | - |
19 | | - const runtime = new EdgeRuntime({ |
20 | | - extend(context) { |
21 | | - const module = { exports: {} } |
22 | | - |
23 | | - context.module = module |
24 | | - context.exports = module.exports |
25 | | - context.__filename = distEntryPath |
26 | | - context.__dirname = path.dirname(distEntryPath) |
27 | | - context.require = (specifier) => { |
28 | | - if (specifier === 'onnxruntime-web') { |
29 | | - return { |
30 | | - env: { wasm: { numThreads: 0 } }, |
31 | | - InferenceSession: { |
32 | | - async create(_model, options) { |
33 | | - usedWasmRuntime = true |
34 | | - executionProviders = options.executionProviders |
35 | | - throw new Error('forced edge-runtime wasm inference failure') |
36 | | - }, |
| 8 | + |
| 9 | +const transformEsmForEdgeRuntime = (source) => |
| 10 | + source |
| 11 | + .replace( |
| 12 | + 'import { toBase64String } from "@sovereignbase/bytecodec";', |
| 13 | + 'const { toBase64String } = await __import("@sovereignbase/bytecodec");' |
| 14 | + ) |
| 15 | + .replace( |
| 16 | + 'import { SentencePieceProcessor } from "@sctg/sentencepiece-js";', |
| 17 | + 'const { SentencePieceProcessor } = await __import("@sctg/sentencepiece-js");' |
| 18 | + ) |
| 19 | + .replace( |
| 20 | + 'return import("onnxruntime-web/all");', |
| 21 | + 'return __import("onnxruntime-web/all");' |
| 22 | + ) |
| 23 | + .replace( |
| 24 | + 'const runtime = await import("onnxruntime-web");', |
| 25 | + 'const runtime = await __import("onnxruntime-web");' |
| 26 | + ) |
| 27 | + .replace( |
| 28 | + /export\s*\{\s*GPUAccelerationSupported,\s*LocalInferenceUtilsError,\s*createInferenceSession,\s*createTokenizer\s*\};/, |
| 29 | + 'return { GPUAccelerationSupported, LocalInferenceUtilsError, createInferenceSession, createTokenizer };' |
| 30 | + ) |
| 31 | + |
| 32 | +const runtime = new EdgeRuntime({ |
| 33 | + extend(context) { |
| 34 | + let usedWasmRuntime = false |
| 35 | + let usedBrowserRuntime = false |
| 36 | + let executionProviders |
| 37 | + |
| 38 | + class SentencePieceProcessor { |
| 39 | + async loadFromB64StringModel(model) { |
| 40 | + this.loadedModel = model |
| 41 | + } |
| 42 | + } |
| 43 | + |
| 44 | + context.__edgeTestState = { |
| 45 | + getExecutionProviders() { |
| 46 | + return executionProviders |
| 47 | + }, |
| 48 | + usedBrowserRuntime() { |
| 49 | + return usedBrowserRuntime |
| 50 | + }, |
| 51 | + usedWasmRuntime() { |
| 52 | + return usedWasmRuntime |
| 53 | + }, |
| 54 | + } |
| 55 | + |
| 56 | + context.__import = async (specifier) => { |
| 57 | + if (specifier === 'onnxruntime-web') { |
| 58 | + return { |
| 59 | + env: { wasm: { numThreads: 0 } }, |
| 60 | + InferenceSession: { |
| 61 | + async create(_model, options) { |
| 62 | + usedWasmRuntime = true |
| 63 | + executionProviders = options.executionProviders |
| 64 | + throw new Error('forced edge-runtime wasm inference failure') |
37 | 65 | }, |
38 | | - } |
| 66 | + }, |
39 | 67 | } |
| 68 | + } |
40 | 69 |
|
41 | | - if (specifier === 'onnxruntime-web/all') { |
42 | | - return { |
43 | | - InferenceSession: { |
44 | | - async create() { |
45 | | - usedBrowserRuntime = true |
46 | | - throw new Error('browser runtime should not be selected') |
47 | | - }, |
| 70 | + if (specifier === 'onnxruntime-web/all') { |
| 71 | + return { |
| 72 | + InferenceSession: { |
| 73 | + async create() { |
| 74 | + usedBrowserRuntime = true |
| 75 | + throw new Error('browser runtime should not be selected') |
48 | 76 | }, |
49 | | - } |
| 77 | + }, |
50 | 78 | } |
| 79 | + } |
51 | 80 |
|
52 | | - if (specifier === '@sctg/sentencepiece-js') { |
53 | | - return { |
54 | | - SentencePieceProcessor: class SentencePieceProcessor {}, |
55 | | - } |
56 | | - } |
| 81 | + if (specifier === '@sctg/sentencepiece-js') { |
| 82 | + return { SentencePieceProcessor } |
| 83 | + } |
57 | 84 |
|
58 | | - if (specifier === '@sovereignbase/bytecodec') { |
59 | | - return { |
60 | | - toBase64String() { |
61 | | - return '' |
62 | | - }, |
63 | | - } |
| 85 | + if (specifier === '@sovereignbase/bytecodec') { |
| 86 | + return { |
| 87 | + toBase64String() { |
| 88 | + return 'edge-tokenizer-model' |
| 89 | + }, |
64 | 90 | } |
65 | | - |
66 | | - return nodeRequire(specifier) |
67 | 91 | } |
68 | 92 |
|
69 | | - return context |
70 | | - }, |
71 | | - }) |
| 93 | + throw new Error(`unexpected edge-runtime import: ${specifier}`) |
| 94 | + } |
72 | 95 |
|
73 | | - runtime.evaluate(distSource) |
| 96 | + return context |
| 97 | + }, |
| 98 | +}) |
74 | 99 |
|
75 | | - const utils = runtime.context.module.exports |
| 100 | +runtime.evaluate(` |
| 101 | +globalThis.__utilsPromise = (async (__import) => { |
| 102 | +${transformEsmForEdgeRuntime(distSource)} |
| 103 | +})(globalThis.__import); |
| 104 | +`) |
76 | 105 |
|
77 | | - assert.equal(typeof utils.GPUAccelerationSupported, 'function') |
78 | | - assert.equal(typeof utils.createInferenceSession, 'function') |
79 | | - assert.equal(utils.GPUAccelerationSupported(), false) |
| 106 | +const utils = await runtime.context.__utilsPromise |
| 107 | +const state = runtime.context.__edgeTestState |
80 | 108 |
|
81 | | - await assert.rejects( |
82 | | - () => utils.createInferenceSession(new Uint8Array([0, 1, 2])), |
83 | | - (error) => { |
84 | | - assert.equal(error.name, 'LocalInferenceUtilsError') |
85 | | - assert.equal(error.code, 'INFERENCE_SESSION_CREATE_FAILED') |
86 | | - assert.equal(usedWasmRuntime, true) |
87 | | - assert.equal(usedBrowserRuntime, false) |
88 | | - assert.deepEqual(Array.from(executionProviders), ['wasm']) |
89 | | - assert.ok(error.cause instanceof Error) |
90 | | - return true |
91 | | - } |
92 | | - ) |
93 | | -}) |
| 109 | +let passed = 0 |
| 110 | +const total = 3 |
| 111 | + |
| 112 | +const tokenizer = await utils.createTokenizer(new Uint8Array([1, 2, 3])) |
| 113 | +assert.equal(tokenizer.loadedModel, 'edge-tokenizer-model') |
| 114 | +passed += 1 |
| 115 | + |
| 116 | +assert.equal(utils.GPUAccelerationSupported(), false) |
| 117 | +passed += 1 |
| 118 | + |
| 119 | +await assert.rejects( |
| 120 | + () => utils.createInferenceSession(new Uint8Array([0, 1, 2])), |
| 121 | + (error) => { |
| 122 | + assert.equal(error.name, 'LocalInferenceUtilsError') |
| 123 | + assert.equal(error.code, 'INFERENCE_SESSION_CREATE_FAILED') |
| 124 | + assert.equal(state.usedWasmRuntime(), true) |
| 125 | + assert.equal(state.usedBrowserRuntime(), false) |
| 126 | + assert.deepEqual(Array.from(state.getExecutionProviders()), ['wasm']) |
| 127 | + assert.ok(error.cause instanceof Error) |
| 128 | + return true |
| 129 | + } |
| 130 | +) |
| 131 | +passed += 1 |
| 132 | + |
| 133 | +console.log('=== Edge Runtimes E2E ===') |
| 134 | +console.log(`edge-runtime esm: ${passed}/${total} passed`) |
0 commit comments