goscript 0.1.3 → 0.2.0

package/gs/testing/testing.test.ts

@@ -1,4 +1,6 @@
 import { describe, expect, it } from 'vitest'
+import { existsSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
 
 import { B, F, Short, T, type TB } from './testing.js'
 import { runTests } from './testing.js'
@@ -101,7 +103,76 @@ describe('testing.T', () => {
 
     t.Cleanup(null)
 
-    await expect(t.runCleanups()).rejects.toThrow('testing: nil cleanup function')
+    await expect(t.runCleanups()).rejects.toThrow(
+      'testing: nil cleanup function',
+    )
+  })
+
+  it('propagates process exits out of subtests without cleanup', async () => {
+    const t = new T('root')
+    const exit = { __goscriptExitCode: 7 }
+    let cleaned = false
+
+    await expect(
+      t.Run('child', (child) => {
+        child.Cleanup(() => {
+          cleaned = true
+        })
+        throw exit
+      }),
+    ).rejects.toBe(exit)
+    expect(cleaned).toBe(false)
+  })
+
+  it('propagates process exits out of subtest cleanups', async () => {
+    const t = new T('root')
+    const exit = { __goscriptExitCode: 8 }
+
+    await expect(
+      t.Run('child', (child) => {
+        child.Cleanup(() => {
+          throw exit
+        })
+      }),
+    ).rejects.toBe(exit)
+    expect(t.Failed()).toBe(false)
+  })
+
+  it('propagates process exits out of package tests without cleanup', async () => {
+    const exit = { __goscriptExitCode: 9 }
+    let cleaned = false
+
+    await expect(
+      runTests('example.test/exit', [
+        {
+          name: 'TestExit',
+          fn: (t) => {
+            t.Cleanup(() => {
+              cleaned = true
+            })
+            throw exit
+          },
+        },
+      ]),
+    ).rejects.toBe(exit)
+    expect(cleaned).toBe(false)
+  })
+
+  it('propagates process exits out of package test cleanups', async () => {
+    const exit = { __goscriptExitCode: 10 }
+
+    await expect(
+      runTests('example.test/exit-cleanup', [
+        {
+          name: 'TestExitCleanup',
+          fn: (t) => {
+            t.Cleanup(() => {
+              throw exit
+            })
+          },
+        },
+      ]),
+    ).rejects.toBe(exit)
   })
 
   it('returns a non-nil context', () => {
@@ -110,6 +181,21 @@ describe('testing.T', () => {
     expect(t.Context()).not.toBeNull()
   })
 
+  it('creates unique TempDir paths and removes them during cleanup', async () => {
+    const t = new T('root')
+
+    const first = t.TempDir()
+    const second = t.TempDir()
+    expect(first).not.toBe(second)
+    writeFileSync(join(first, 'marker.txt'), 'marker')
+    expect(existsSync(first)).toBe(true)
+
+    await t.runCleanups()
+
+    expect(existsSync(first)).toBe(false)
+    expect(existsSync(second)).toBe(false)
+  })
+
   it('formats common testing printf verbs', () => {
     const t = new T('root')
     const messages: string[] = []
@@ -118,13 +204,23 @@ describe('testing.T', () => {
       messages.push(String(message))
     }
     try {
-      t.Logf('quoted=%q value=%#v plus=%+v number=%d string=%s plain=%v', 'key', 7, { ok: true }, 3, 'ok', true)
+      t.Logf(
+        'quoted=%q value=%#v plus=%+v number=%d string=%s plain=%v',
+        'key',
+        7,
+        { ok: true },
+        3,
+        'ok',
+        true,
+      )
       t.flushLogs()
     } finally {
       console.log = originalLog
     }
 
-    expect(messages).toEqual(['    quoted="key" value=7 plus=[object Object] number=3 string=ok plain=true'])
+    expect(messages).toEqual([
+      '    quoted="key" value=7 plus=[object Object] number=3 string=ok plain=true',
+    ])
   })
 
   it('formats Go-style error objects with Error methods', () => {

package/gs/testing/testing.ts

@@ -1,7 +1,3 @@
-import { mkdirSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
 import * as context from '@goscript/context/index.js'
 
 export type TestFunc = (t: T) => void | Promise<void>
@@ -24,6 +20,18 @@ export type RunResult = {
   skipped: number
 }
 
+interface HostProcess {
+  env?: Record<string, string | undefined>
+  cwd?: () => string
+  chdir?: (dir: string) => void
+  getBuiltinModule?: (name: string) => unknown
+}
+
+interface HostGlobal {
+  process?: HostProcess
+  require?: (name: string) => unknown
+}
+
 class TestControl extends Error {
   public readonly kind: 'fatal' | 'skip'
 
@@ -127,6 +135,9 @@ export class T {
     try {
       await fn(child)
     } catch (err) {
+      if (isProcessExitError(err)) {
+        throw err
+      }
       if (err instanceof TestControl && err.kind === 'skip') {
         // A skipped subtest is still a successful Run result.
       } else {
@@ -139,6 +150,9 @@ export class T {
     try {
       await child.runCleanups()
     } catch (err) {
+      if (isProcessExitError(err)) {
+        throw err
+      }
       child.Fail()
       if (!(err instanceof TestControl)) {
         child.Log(formatValue(err))
@@ -153,28 +167,40 @@ export class T {
   }
 
   public TempDir(): string {
-    const path = join(
-      tmpdir(),
-      'goscript-test-' +
-        this.testName.replace(/[^A-Za-z0-9_.-]/g, '_') +
-        '-' +
-        String(this.tempDirs.length),
+    const fs = requireHostModule<{
+      mkdtempSync(prefix: string): string
+      rmSync(path: string, opts: { force: boolean; recursive: boolean }): void
+    }>('node:fs', 'testing.TempDir')
+    const os = requireHostModule<{ tmpdir(): string }>(
+      'node:os',
+      'testing.TempDir',
+    )
+    const pathMod = requireHostModule<{ join(...parts: string[]): string }>(
+      'node:path',
+      'testing.TempDir',
+    )
+    const path = fs.mkdtempSync(
+      pathMod.join(
+        os.tmpdir(),
+        'goscript-test-' +
+          this.testName.replace(/[^A-Za-z0-9_.-]/g, '_') +
+          '-' +
+          String(this.tempDirs.length),
+      ) + '-',
     )
-    mkdirSync(path, { recursive: true })
     this.tempDirs.push(path)
+    this.Cleanup(() => {
+      fs.rmSync(path, { force: true, recursive: true })
+    })
     return path
   }
 
-  public Parallel(): void {
-  }
+  public Parallel(): void {}
 
   public Setenv(key: string, value: string): void {
-    const proc = (globalThis as any).process as
-      | { env?: Record<string, string | undefined> }
-      | undefined
-    const env = proc?.env
+    const env = (globalThis as HostGlobal).process?.env
     if (env === undefined) {
-      return
+      throw new Error('testing.Setenv is not supported without a host process')
     }
     const oldValue = env[key]
     env[key] = value
@@ -188,11 +214,9 @@ export class T {
   }
 
   public Chdir(dir: string): void {
-    const proc = (globalThis as any).process as
-      | { cwd?: () => string; chdir?: (dir: string) => void }
-      | undefined
+    const proc = (globalThis as HostGlobal).process
     if (proc?.cwd === undefined || proc.chdir === undefined) {
-      return
+      throw new Error('testing.Chdir is not supported without a host process')
     }
     const oldDir = proc.cwd()
     proc.chdir(dir)
@@ -246,6 +270,9 @@ export class B extends T {
     try {
       await fn(child)
     } catch (err) {
+      if (isProcessExitError(err)) {
+        throw err
+      }
       child.Error(err)
     }
     if (child.Failed()) {
@@ -325,6 +352,9 @@ export async function runTests(
         try {
           await test.fn(t)
         } catch (err) {
+          if (isProcessExitError(err)) {
+            throw err
+          }
           if (err instanceof TestControl && err.kind === 'skip') {
             skipped++
           } else {
@@ -333,9 +363,8 @@ export async function runTests(
               t.Log(formatValue(err))
             }
           }
-        } finally {
-          await t.runCleanups()
         }
+        await t.runCleanups()
         const elapsed = ((Date.now() - start) / 1000).toFixed(2)
         if (t.Skipped()) {
           if (options.verbose) {
@@ -380,6 +409,48 @@ function formatMessage(format: string, args: unknown[]): string {
   })
 }
 
+function requireHostModule<T>(name: string, api: string): T {
+  const fromProcess = (globalThis as HostGlobal).process?.getBuiltinModule?.(
+    name,
+  )
+  if (fromProcess !== undefined && fromProcess !== null) {
+    return fromProcess as T
+  }
+  const req = hostRequire()
+  if (req !== undefined) {
+    return req(name) as T
+  }
+  throw new Error(
+    api + ' is not supported without Node-compatible host modules',
+  )
+}
+
+function hostRequire(): ((name: string) => unknown) | undefined {
+  const globalRequire = (globalThis as HostGlobal).require
+  if (typeof globalRequire === 'function') {
+    return globalRequire
+  }
+  try {
+    const req = eval(
+      'typeof require === "function" ? require : undefined',
+    ) as unknown
+    if (typeof req === 'function') {
+      return req as (name: string) => unknown
+    }
+  } catch {
+    return undefined
+  }
+  return undefined
+}
+
+function isProcessExitError(err: unknown): boolean {
+  if (err === null || typeof err !== 'object') {
+    return false
+  }
+  const code = (err as { __goscriptExitCode?: unknown }).__goscriptExitCode
+  return typeof code === 'number'
+}
+
 function formatValue(value: unknown): string {
   if (value instanceof Error) {
     return value.message

package/gs/time/parity.json

@@ -0,0 +1,225 @@
+{
+  "schemaVersion": 1,
+  "strict": true,
+  "symbols": {
+    "After": {
+      "status": "real"
+    },
+    "AfterFunc": {
+      "status": "real"
+    },
+    "ANSIC": {
+      "status": "real"
+    },
+    "April": {
+      "status": "real"
+    },
+    "August": {
+      "status": "real"
+    },
+    "Date": {
+      "status": "real"
+    },
+    "DateOnly": {
+      "status": "real"
+    },
+    "DateTime": {
+      "status": "real"
+    },
+    "December": {
+      "status": "real"
+    },
+    "Duration": {
+      "status": "real"
+    },
+    "February": {
+      "status": "real"
+    },
+    "FixedZone": {
+      "status": "real"
+    },
+    "Friday": {
+      "status": "real"
+    },
+    "Hour": {
+      "status": "real"
+    },
+    "January": {
+      "status": "real"
+    },
+    "July": {
+      "status": "real"
+    },
+    "June": {
+      "status": "real"
+    },
+    "Kitchen": {
+      "status": "real"
+    },
+    "Layout": {
+      "status": "real"
+    },
+    "LoadLocation": {
+      "status": "real"
+    },
+    "LoadLocationFromTZData": {
+      "status": "real"
+    },
+    "Local": {
+      "status": "real"
+    },
+    "Location": {
+      "status": "real"
+    },
+    "March": {
+      "status": "real"
+    },
+    "May": {
+      "status": "real"
+    },
+    "Microsecond": {
+      "status": "real"
+    },
+    "Millisecond": {
+      "status": "real"
+    },
+    "Minute": {
+      "status": "real"
+    },
+    "Monday": {
+      "status": "real"
+    },
+    "Month": {
+      "status": "real"
+    },
+    "Nanosecond": {
+      "status": "real"
+    },
+    "NewTicker": {
+      "status": "real"
+    },
+    "NewTimer": {
+      "status": "real"
+    },
+    "November": {
+      "status": "real"
+    },
+    "Now": {
+      "status": "real"
+    },
+    "October": {
+      "status": "real"
+    },
+    "Parse": {
+      "status": "real"
+    },
+    "ParseDuration": {
+      "status": "real"
+    },
+    "ParseError": {
+      "status": "real"
+    },
+    "ParseInLocation": {
+      "status": "real"
+    },
+    "RFC1123": {
+      "status": "real"
+    },
+    "RFC1123Z": {
+      "status": "real"
+    },
+    "RFC3339": {
+      "status": "real"
+    },
+    "RFC3339Nano": {
+      "status": "real"
+    },
+    "RFC822": {
+      "status": "real"
+    },
+    "RFC822Z": {
+      "status": "real"
+    },
+    "RFC850": {
+      "status": "real"
+    },
+    "RubyDate": {
+      "status": "real"
+    },
+    "Saturday": {
+      "status": "real"
+    },
+    "Second": {
+      "status": "real"
+    },
+    "September": {
+      "status": "real"
+    },
+    "Since": {
+      "status": "real"
+    },
+    "Sleep": {
+      "status": "real"
+    },
+    "Stamp": {
+      "status": "real"
+    },
+    "StampMicro": {
+      "status": "real"
+    },
+    "StampMilli": {
+      "status": "real"
+    },
+    "StampNano": {
+      "status": "real"
+    },
+    "Sunday": {
+      "status": "real"
+    },
+    "Thursday": {
+      "status": "real"
+    },
+    "Tick": {
+      "status": "real"
+    },
+    "Ticker": {
+      "status": "real"
+    },
+    "Time": {
+      "status": "real"
+    },
+    "TimeOnly": {
+      "status": "real"
+    },
+    "Timer": {
+      "status": "real"
+    },
+    "Tuesday": {
+      "status": "real"
+    },
+    "Unix": {
+      "status": "real"
+    },
+    "UnixDate": {
+      "status": "real"
+    },
+    "UnixMicro": {
+      "status": "real"
+    },
+    "UnixMilli": {
+      "status": "real"
+    },
+    "Until": {
+      "status": "real"
+    },
+    "UTC": {
+      "status": "real"
+    },
+    "Wednesday": {
+      "status": "real"
+    },
+    "Weekday": {
+      "status": "real"
+    }
+  }
+}

package/gs/time/time.test.ts

@@ -3,6 +3,7 @@ import { describe, expect, it } from 'vitest'
 import * as $ from '@goscript/builtin/index.js'
 
 import {
+  ANSIC,
   Duration_Abs,
   Duration_Hours,
   Duration_Microseconds,
@@ -14,14 +15,22 @@ import {
   Duration_String,
   Duration_Truncate,
   FixedZone,
+  Friday,
   January,
+  Kitchen,
+  Local,
   Microsecond,
   Millisecond,
   Minute,
+  Month_String,
   NewTicker,
   NewTimer,
+  RFC1123,
   RFC3339Nano,
+  Saturday,
   Second,
+  StampMicro,
+  Sunday,
   Date,
   May,
   RFC3339,
@@ -67,12 +76,21 @@ describe('time.Duration methods', () => {
 })
 
 describe('time constants and timers', () => {
-  it('exports RFC3339Nano', () => {
+  it('exports layout and location constants', () => {
+    expect(ANSIC).toBe('Mon Jan _2 15:04:05 2006')
+    expect(RFC1123).toBe('Mon, 02 Jan 2006 15:04:05 MST')
     expect(RFC3339Nano).toBe('2006-01-02T15:04:05.999999999Z07:00')
+    expect(Kitchen).toBe('3:04PM')
+    expect(StampMicro).toBe('Jan _2 15:04:05.000000')
+    expect(Local.String()).toBe('Local')
   })
 
-  it('exports month constants directly', () => {
+  it('exports month and weekday constants directly', () => {
     expect(January).toBe(1)
+    expect(Month_String(May)).toBe('May')
+    expect(Sunday).toBe(0)
+    expect(Friday).toBe(5)
+    expect(Saturday).toBe(6)
   })
 
   it('delivers NewTimer values on C', async () => {