+16

tests/fixtures/process_stdout_resize_child.cjs

reviewed

··· 1 1 + let resizeCount = 0; 2 2 + 3 3 + process.stdout.on('resize', () => { 4 4 + resizeCount++; 5 5 + console.log(`RESIZE ${process.stdout.rows} ${process.stdout.columns}`); 6 6 + setTimeout(() => process.exit(0), 25); 7 7 + }); 8 8 + 9 9 + console.log('READY'); 10 10 + 11 11 + setTimeout(() => { 12 12 + if (resizeCount === 0) { 13 13 + console.error('resize event did not fire'); 14 14 + process.exit(2); 15 15 + } 16 16 + }, 3000);

+74

tests/test_debug_error_trace.cjs

reviewed

··· 1 1 + const { spawnSync } = require('child_process'); 2 2 + const fs = require('fs'); 3 3 + const os = require('os'); 4 4 + const path = require('path'); 5 5 + 6 6 + function assert(condition, message) { 7 7 + if (!condition) throw new Error(message); 8 8 + } 9 9 + 10 10 + function runCase(bin, dir, file, source) { 11 11 + const scriptPath = path.join(dir, file); 12 12 + fs.writeFileSync(scriptPath, source); 13 13 + 14 14 + const result = spawnSync(bin, [scriptPath], { 15 15 + env: { ...process.env, ANT_DEBUG: 'dump/errors:trace' }, 16 16 + encoding: 'utf8', 17 17 + }); 18 18 + 19 19 + if (result.error) throw result.error; 20 20 + return { scriptPath, ...result }; 21 21 + } 22 22 + 23 23 + const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ant-debug-errors-')); 24 24 + const bin = path.resolve(__dirname, '..', 'build', 'ant'); 25 25 + 26 26 + const thrown = runCase( 27 27 + bin, 28 28 + tmpDir, 29 29 + 'throw-project-path.cjs', 30 30 + "throw new Error('Project path is required');\n" 31 31 + ); 32 32 + assert(thrown.status !== 0, 'throw case should fail'); 33 33 + assert( 34 34 + thrown.stderr.includes('[ant-debug:error] throw Error: Project path is required'), 35 35 + `expected throw trace in stderr\n${thrown.stderr}` 36 36 + ); 37 37 + assert( 38 38 + thrown.stderr.includes(`site: ${thrown.scriptPath}:1:`), 39 39 + `expected throw site in stderr\n${thrown.stderr}` 40 40 + ); 41 41 + 42 42 + const missing = runCase( 43 43 + bin, 44 44 + tmpDir, 45 45 + 'missing-bailing.cjs', 46 46 + "console.log(bailing);\n" 47 47 + ); 48 48 + assert(missing.status !== 0, 'missing identifier case should fail'); 49 49 + assert( 50 50 + missing.stderr.includes('[ant-debug:error] create ReferenceError'), 51 51 + `expected ReferenceError trace in stderr\n${missing.stderr}` 52 52 + ); 53 53 + assert( 54 54 + missing.stderr.includes('bailing'), 55 55 + `expected missing identifier name in stderr\n${missing.stderr}` 56 56 + ); 57 57 + 58 58 + const constAssign = runCase( 59 59 + bin, 60 60 + tmpDir, 61 61 + 'const-assign.cjs', 62 62 + "const value = 1;\nvalue = 2;\n" 63 63 + ); 64 64 + assert(constAssign.status !== 0, 'const assignment case should fail'); 65 65 + assert( 66 66 + constAssign.stderr.includes('[ant-debug:error] create TypeError: Assignment to constant variable'), 67 67 + `expected const assignment trace in stderr\n${constAssign.stderr}` 68 68 + ); 69 69 + assert( 70 70 + constAssign.stderr.includes(`site: ${constAssign.scriptPath}:2:`), 71 71 + `expected const assignment site in stderr\n${constAssign.stderr}` 72 72 + ); 73 73 + 74 74 + console.log('debug error trace test passed');

+26

tests/test_inspect_custom.cjs

reviewed

··· 32 32 33 33 const blob = new Blob(['hi'], { type: 'text/plain' }); 34 34 const file = new File(['hi'], 'note.txt', { type: 'text/plain', lastModified: 42 }); 35 35 + const headers = new Headers({ 'content-type': 'text/plain' }); 36 36 + const request = new Request('https://google.com'); 37 37 + const response = new Response('ok', { headers }); 35 38 const timeout = setTimeout(() => {}, 1); 36 39 const interval = setInterval(() => {}, 5); 40 40 + const headersInspect = inspect(headers); 37 41 const timeoutInspect = inspect(timeout); 38 42 const intervalInspect = inspect(interval); 43 43 + const requestInspect = inspect(request); 44 44 + const responseInspect = inspect(response); 45 45 + 46 46 + assert(typeof Headers.prototype[Symbol.inspect] === 'function', 'expected Headers.prototype[Symbol.inspect] to exist'); 47 47 + assert(typeof Request.prototype[Symbol.inspect] === 'function', 'expected Request.prototype[Symbol.inspect] to exist'); 48 48 + assert(typeof Response.prototype[Symbol.inspect] === 'function', 'expected Response.prototype[Symbol.inspect] to exist'); 39 49 40 50 assert(inspect(new Connection('localhost', 3000, 'open')) === 'Connection { localhost:3000 (open) }', 'expected custom inspect result'); 41 51 assert(inspect(blob) === "Blob { size: 2, type: 'text/plain' }", 'expected Blob custom inspect output'); 42 52 assert(inspect(file) === "File { size: 2, type: 'text/plain', name: 'note.txt', lastModified: 42 }", 'expected File custom inspect output'); 53 53 + assert( 54 54 + Headers.prototype[Symbol.inspect].call(headers) === headersInspect, 55 55 + `expected Headers Symbol.inspect output, got: ${Headers.prototype[Symbol.inspect].call(headers)}` 56 56 + ); 57 57 + assert( 58 58 + requestInspect === "Request {\n method: 'GET',\n url: 'https://google.com/',\n headers: Headers {},\n destination: '',\n referrer: 'about:client',\n referrerPolicy: '',\n mode: 'cors',\n credentials: 'same-origin',\n cache: 'default',\n redirect: 'follow',\n integrity: '',\n keepalive: false,\n isReloadNavigation: false,\n isHistoryNavigation: false,\n signal: AbortSignal { aborted: false }\n}", 59 59 + `expected Request inspect output, got: ${requestInspect}` 60 60 + ); 61 61 + assert( 62 62 + Request.prototype[Symbol.inspect].call(request) === requestInspect, 63 63 + `expected Request Symbol.inspect output, got: ${Request.prototype[Symbol.inspect].call(request)}` 64 64 + ); 65 65 + assert( 66 66 + Response.prototype[Symbol.inspect].call(response) === responseInspect, 67 67 + `expected Response Symbol.inspect output, got: ${Response.prototype[Symbol.inspect].call(response)}` 68 68 + ); 43 69 assert( 44 70 timeoutInspect === 'Timeout (1) {\n delay: 1,\n repeat: null,\n [Symbol(Symbol.toPrimitive)]: [native code]\n}', 45 71 `expected legacy Timeout inspect output, got: ${timeoutInspect}`

+63

tests/test_object_fromentries_iterables.cjs

reviewed

··· 1 1 + const assert = require("node:assert"); 2 2 + 3 3 + assert.deepStrictEqual( 4 4 + Object.fromEntries(new Map([ 5 5 + ["a", 1], 6 6 + ["b", 2], 7 7 + ])), 8 8 + { a: 1, b: 2 }, 9 9 + ); 10 10 + 11 11 + function* pairGenerator() { 12 12 + yield ["x", 10]; 13 13 + yield ["y", 20]; 14 14 + } 15 15 + 16 16 + assert.deepStrictEqual( 17 17 + Object.fromEntries(pairGenerator()), 18 18 + { x: 10, y: 20 }, 19 19 + ); 20 20 + 21 21 + const iterable = { 22 22 + [Symbol.iterator]: function* () { 23 23 + yield ["left", "right"]; 24 24 + yield ["up", "down"]; 25 25 + }, 26 26 + }; 27 27 + 28 28 + assert.deepStrictEqual( 29 29 + Object.fromEntries(iterable), 30 30 + { left: "right", up: "down" }, 31 31 + ); 32 32 + 33 33 + class RequestContextLike { 34 34 + constructor() { 35 35 + this.registry = new Map(); 36 36 + } 37 37 + 38 38 + set(key, value) { 39 39 + this.registry.set(key, value); 40 40 + } 41 41 + 42 42 + entries() { 43 43 + return this.registry.entries(); 44 44 + } 45 45 + } 46 46 + 47 47 + const ctx = new RequestContextLike(); 48 48 + ctx.set("harness", { 49 49 + state: { projectPath: "/tmp/project" }, 50 50 + getState() { 51 51 + return this.state; 52 52 + }, 53 53 + }); 54 54 + 55 55 + const snapshot = Object.fromEntries(ctx.entries()); 56 56 + assert.strictEqual(snapshot.harness.getState().projectPath, "/tmp/project"); 57 57 + 58 58 + assert.throws( 59 59 + () => Object.fromEntries((function* () { yield 1; })()), 60 60 + /entry objects/, 61 61 + ); 62 62 + 63 63 + console.log("Object.fromEntries consumes Map iterators, generators, and custom iterables");

+108

tests/test_process_stdout_resize_signal.cjs

reviewed

··· 1 1 + const { spawnSync } = require('child_process'); 2 2 + const path = require('path'); 3 3 + 4 4 + function fail(message) { 5 5 + throw new Error(message); 6 6 + } 7 7 + 8 8 + function runInPty() { 9 9 + const helper = path.join(__dirname, 'fixtures', 'process_stdout_resize_child.cjs'); 10 10 + const script = ` 11 11 + import fcntl, os, select, signal, struct, sys, termios, time 12 12 + 13 13 + exec_path, helper = sys.argv[1], sys.argv[2] 14 14 + pid, master = os.forkpty() 15 15 + 16 16 + if pid == 0: 17 17 + os.execv(exec_path, [exec_path, helper]) 18 18 + 19 19 + buf = bytearray() 20 20 + sent = False 21 21 + exit_code = None 22 22 + deadline = time.time() + 7.0 23 23 + 24 24 + while time.time() < deadline: 25 25 + done, status = os.waitpid(pid, os.WNOHANG) 26 26 + if done == pid: 27 27 + exit_code = os.waitstatus_to_exitcode(status) 28 28 + break 29 29 + 30 30 + r, _, _ = select.select([master], [], [], 0.1) 31 31 + if master not in r: 32 32 + continue 33 33 + 34 34 + try: 35 35 + chunk = os.read(master, 4096) 36 36 + except OSError: 37 37 + break 38 38 + 39 39 + if not chunk: 40 40 + break 41 41 + 42 42 + buf.extend(chunk) 43 43 + if (not sent) and b'READY' in buf: 44 44 + winsz = struct.pack('HHHH', 40, 120, 0, 0) 45 45 + fcntl.ioctl(master, termios.TIOCSWINSZ, winsz) 46 46 + os.kill(pid, signal.SIGWINCH) 47 47 + sent = True 48 48 + 49 49 + if exit_code is None: 50 50 + os.kill(pid, signal.SIGKILL) 51 51 + _, status = os.waitpid(pid, 0) 52 52 + exit_code = os.waitstatus_to_exitcode(status) 53 53 + 54 54 + while True: 55 55 + r, _, _ = select.select([master], [], [], 0.05) 56 56 + if master not in r: 57 57 + break 58 58 + try: 59 59 + chunk = os.read(master, 4096) 60 60 + except OSError: 61 61 + break 62 62 + if not chunk: 63 63 + break 64 64 + buf.extend(chunk) 65 65 + 66 66 + sys.stdout.buffer.write(bytes(buf)) 67 67 + sys.exit(exit_code) 68 68 + `; 69 69 + 70 70 + if (process.platform === 'win32') { 71 71 + console.log('skipping stdout resize signal test on win32'); 72 72 + process.exit(0); 73 73 + } 74 74 + 75 75 + return spawnSync('python3', ['-c', script, process.execPath, helper], { 76 76 + encoding: 'utf8', 77 77 + timeout: 9000, 78 78 + }); 79 79 + } 80 80 + 81 81 + const result = runInPty(); 82 82 + 83 83 + if (result.error && result.error.code === 'ENOENT') { 84 84 + console.log('skipping stdout resize signal test because `python3` is unavailable'); 85 85 + process.exit(0); 86 86 + } 87 87 + 88 88 + if (result.error) throw result.error; 89 89 + 90 90 + const output = `${result.stdout || ''}${result.stderr || ''}`; 91 91 + 92 92 + if (result.status !== 0) { 93 93 + fail(`child exited ${result.status}\n${output}`); 94 94 + } 95 95 + 96 96 + if (!output.includes('READY')) { 97 97 + fail(`expected READY banner\n${output}`); 98 98 + } 99 99 + 100 100 + if (!output.includes('RESIZE 40 120')) { 101 101 + fail(`expected resize output with updated tty dimensions\n${output}`); 102 102 + } 103 103 + 104 104 + if (output.includes('assignment to constant')) { 105 105 + fail(`resize handling regressed with assignment-to-constant error\n${output}`); 106 106 + } 107 107 + 108 108 + console.log('process.stdout resize signal updates dimensions without crashing');

+37

tests/test_proxy_object_entries.cjs

reviewed

··· 1 1 + const assert = require("node:assert"); 2 2 + 3 3 + let getCalls = 0; 4 4 + 5 5 + const proxy = new Proxy({}, { 6 6 + ownKeys() { 7 7 + return ["kimi-for-coding", "hidden", Symbol("skip")]; 8 8 + }, 9 9 + getOwnPropertyDescriptor(_target, prop) { 10 10 + if (prop === "kimi-for-coding") { 11 11 + return { enumerable: true, configurable: true }; 12 12 + } 13 13 + if (prop === "hidden") { 14 14 + return { enumerable: false, configurable: true }; 15 15 + } 16 16 + if (typeof prop === "symbol") { 17 17 + return { enumerable: true, configurable: true }; 18 18 + } 19 19 + }, 20 20 + get(_target, prop) { 21 21 + getCalls++; 22 22 + if (prop === "kimi-for-coding") { 23 23 + return { apiKeyEnvVar: "KIMI_API_KEY" }; 24 24 + } 25 25 + if (prop === "hidden") { 26 26 + return { apiKeyEnvVar: "HIDDEN_API_KEY" }; 27 27 + } 28 28 + return { apiKeyEnvVar: "SYMBOL_API_KEY" }; 29 29 + } 30 30 + }); 31 31 + 32 32 + assert.deepStrictEqual(Object.keys(proxy), ["kimi-for-coding"]); 33 33 + assert.deepStrictEqual(Object.values(proxy), [{ apiKeyEnvVar: "KIMI_API_KEY" }]); 34 34 + assert.deepStrictEqual(Object.entries(proxy), [["kimi-for-coding", { apiKeyEnvVar: "KIMI_API_KEY" }]]); 35 35 + assert.strictEqual(getCalls, 2); 36 36 + 37 37 + console.log("proxy Object.keys/Object.values/Object.entries respect proxy traps");

+46

tests/test_regexp_exec_fast_paths.cjs

reviewed

··· 59 59 'custom exec truthiness lowering should preserve getter/arg/call order' 60 60 ); 61 61 62 62 + const testGets = []; 63 63 + const testProxy = new Proxy( 64 64 + { 65 65 + exec() { 66 66 + return null; 67 67 + } 68 68 + }, 69 69 + { 70 70 + get(target, key) { 71 71 + testGets.push(key); 72 72 + return target[key]; 73 73 + } 74 74 + } 75 75 + ); 76 76 + 77 77 + assert(RegExp.prototype.test.call(testProxy) === false, 'proxy-backed test should return false'); 78 78 + assert(testGets.join(',') === 'exec', 'RegExp.prototype.test should only Get("exec") once'); 79 79 + 80 80 + const flagKeys = []; 81 81 + const flagProxy = new Proxy( 82 82 + {}, 83 83 + { 84 84 + get(target, key) { 85 85 + flagKeys.push(key); 86 86 + return target[key]; 87 87 + } 88 88 + } 89 89 + ); 90 90 + 91 91 + Object.getOwnPropertyDescriptor(RegExp.prototype, 'flags').get.call(flagProxy); 92 92 + 93 93 + const expectedFlagKeys = []; 94 94 + if ('hasIndices' in RegExp.prototype) expectedFlagKeys.push('hasIndices'); 95 95 + if ('global' in RegExp.prototype) expectedFlagKeys.push('global'); 96 96 + if ('ignoreCase' in RegExp.prototype) expectedFlagKeys.push('ignoreCase'); 97 97 + if ('multiline' in RegExp.prototype) expectedFlagKeys.push('multiline'); 98 98 + if ('dotAll' in RegExp.prototype) expectedFlagKeys.push('dotAll'); 99 99 + if ('unicode' in RegExp.prototype) expectedFlagKeys.push('unicode'); 100 100 + if ('unicodeSets' in RegExp.prototype) expectedFlagKeys.push('unicodeSets'); 101 101 + if ('sticky' in RegExp.prototype) expectedFlagKeys.push('sticky'); 102 102 + 103 103 + assert( 104 104 + flagKeys.join(',') === expectedFlagKeys.join(','), 105 105 + 'RegExp.prototype.flags should read observable flag properties in spec order' 106 106 + ); 107 107 + 62 108 console.log('regex exec fast path semantics ok');