peachsim 0.1.527

package/cli/commands/test.ts

@@ -0,0 +1,535 @@
+// rnx test — choose Maestro or Detox, support local bundle loopback and standalone cloud execution.
+
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs'
+import { createServer, type Server } from 'node:http'
+import { basename, dirname, extname, join, resolve } from 'node:path'
+import {
+  RNX_CLOUD_TEST_FILES_MAX_BYTES,
+  RNX_CLOUD_TEST_FILES_MAX_COUNT,
+} from '../../src/cloud-contract'
+import { authHeaderValue, resolveCliAuth } from '../auth'
+import { buildShellUrl, resolveShellBaseUrlForBridgePort } from './control'
+import { hoistLeadingSimFlag } from './flow'
+import { resolveDefaultUploadOrigin } from './upload'
+
+export interface RunTestOptions {
+  port?: number
+  verbose?: boolean
+  pollIntervalMs?: number
+  timeoutMs?: number
+}
+
+interface TestAppTarget {
+  target: string
+  close: () => Promise<void>
+}
+
+const VALUE_FLAGS = new Set([
+  '--app',
+  '--bundle',
+  '--bundle-url',
+  '--config',
+  '--sim',
+  '--session',
+  '--tab',
+  '--port',
+  '--device',
+  '--driver',
+  '--base-url',
+  '--url',
+  '-t',
+  '--testNamePattern',
+  '--grep',
+  '--maxWorkers',
+  '--shard',
+  '--outputFile',
+  '--origin',
+  '--owner',
+  '--repo',
+  '--poll-interval',
+  '--timeout',
+])
+
+function valueAfter(args: string[], name: string): string | null {
+  const inline = args.find((arg) => arg.startsWith(`${name}=`))
+  if (inline) return inline.slice(name.length + 1) || null
+  const index = args.indexOf(name)
+  if (index < 0) return null
+  const value = args[index + 1]
+  return value && !value.startsWith('-') ? value : null
+}
+
+function targetFromArgs(args: string[]): string | null {
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index]
+    if (VALUE_FLAGS.has(arg)) {
+      index += 1
+      continue
+    }
+    if (arg.startsWith('--') && arg.includes('=')) {
+      continue
+    }
+    if (!arg.startsWith('-')) return arg
+  }
+  return null
+}
+
+function withoutApp(args: string[]): string[] {
+  const result: string[] = []
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]
+    if (arg === '--app') {
+      i += 1
+      continue
+    }
+    if (arg.startsWith('--app=')) {
+      continue
+    }
+    result.push(arg)
+  }
+  return result
+}
+
+function closeServer(server: Server): Promise<void> {
+  return new Promise((resolveClose, rejectClose) => {
+    server.close((error) => {
+      if (error) rejectClose(error)
+      else resolveClose()
+    })
+  })
+}
+
+export async function servePrebuiltBundle(path: string): Promise<TestAppTarget> {
+  const file = resolve(process.cwd(), path)
+  const stat = statSync(file)
+  if (!stat.isFile() || extname(file) !== '.js') {
+    throw new Error('--app must name a regular Metro .js bundle or a packager target')
+  }
+  const bundle = readFileSync(file)
+  if (bundle.length === 0) throw new Error('--app bundle is empty')
+
+  const server = createServer((request, response) => {
+    if (new URL(request.url || '/', 'http://127.0.0.1').pathname !== '/bundle.js') {
+      response.writeHead(404).end()
+      return
+    }
+    response.writeHead(200, {
+      'access-control-allow-origin': '*',
+      'cache-control': 'no-store',
+      'content-type': 'application/javascript; charset=utf-8',
+      'content-length': String(bundle.length),
+    })
+    response.end(bundle)
+  })
+  await new Promise<void>((resolveListen, rejectListen) => {
+    server.once('error', rejectListen)
+    server.listen(0, '127.0.0.1', () => {
+      server.off('error', rejectListen)
+      resolveListen()
+    })
+  })
+  const address = server.address()
+  if (!address || typeof address === 'string') {
+    await closeServer(server)
+    throw new Error('could not start the local prebuilt-bundle server')
+  }
+  return {
+    target: `http://127.0.0.1:${address.port}/bundle.js`,
+    close: () => closeServer(server),
+  }
+}
+
+export async function resolveTestAppTarget(app: string): Promise<TestAppTarget> {
+  const localPath = resolve(process.cwd(), app)
+  if (existsSync(localPath)) return servePrebuiltBundle(localPath)
+  return { target: app, close: async () => {} }
+}
+
+function restoreRnxUrl(previous: string | undefined): void {
+  if (previous === undefined) {
+    delete process.env.RNX_URL
+  } else {
+    process.env.RNX_URL = previous
+  }
+}
+
+// dispatch only: each interpreter retains its own selection and execution rules.
+export function resolveTestCommand(args: string[], cwd = process.cwd()) {
+  const forwarded = hoistLeadingSimFlag(args)
+  const target = forwarded[0]?.startsWith('-') ? undefined : forwarded[0]
+  const config = forwarded.some(
+    (arg) => arg === '--config' || arg.startsWith('--config='),
+  )
+  if (config) return { command: 'detox', args: forwarded }
+  if (!target) {
+    throw new Error(
+      'pass a Maestro flow/directory, a Jest suite, or --config <jest-config>',
+    )
+  }
+  const absolute = resolve(cwd, target)
+  if (!existsSync(absolute)) throw new Error(`test target not found: ${target}`)
+  const directory = statSync(absolute).isDirectory()
+  if (
+    !directory &&
+    /^(?:jest|rnx-detox)\.config\.[cm]?[jt]s$|^jest\.config\.json$/.test(
+      basename(absolute),
+    )
+  ) {
+    return { command: 'detox', args: ['--config', target, ...forwarded.slice(1)] }
+  }
+  const maestro = directory
+    ? readdirSync(absolute).some((name) => /\.ya?ml$/.test(name)) ||
+      ['.maestro', 'maestro'].includes(basename(absolute))
+    : /\.ya?ml$/.test(extname(absolute))
+  if (maestro) {
+    return {
+      command: 'maestro',
+      args: [
+        'test',
+        ...forwarded.map((arg, index) => {
+          if (index === 0 && !directory && /^config\.ya?ml$/.test(basename(absolute)))
+            return dirname(absolute)
+          return arg === '--app' || arg.startsWith('--app=')
+            ? arg.replace('--app', '--url')
+            : arg
+        }),
+      ],
+    }
+  }
+  if (!directory && !/\.[cm]?[jt]sx?$/.test(extname(absolute))) {
+    throw new Error(`expected Maestro YAML or a Detox/Jest suite: ${target}`)
+  }
+  return { command: 'detox', args: forwarded }
+}
+
+function collectTestFiles(
+  targetPath: string,
+  ignoredPath: string | null,
+): Record<string, string> {
+  const files: Record<string, string> = {}
+  let sourceBytes = 0
+  const add = (path: string, relativePath: string) => {
+    if (Object.keys(files).length >= RNX_CLOUD_TEST_FILES_MAX_COUNT) {
+      throw new Error(
+        `cloud test suites may contain at most ${RNX_CLOUD_TEST_FILES_MAX_COUNT} files`,
+      )
+    }
+    sourceBytes += statSync(path).size
+    if (sourceBytes > RNX_CLOUD_TEST_FILES_MAX_BYTES) {
+      throw new Error(
+        `cloud test files may contain at most ${RNX_CLOUD_TEST_FILES_MAX_BYTES} bytes`,
+      )
+    }
+    files[relativePath] = readFileSync(path, 'utf8')
+  }
+  const stat = statSync(targetPath)
+  if (stat.isDirectory()) {
+    function walk(dir: string, base: string) {
+      for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        if (entry.name.startsWith('.') && entry.name !== '.maestro') continue
+        if (['node_modules', 'dist', 'build', '.git'].includes(entry.name)) continue
+        const full = join(dir, entry.name)
+        if (ignoredPath && resolve(full) === ignoredPath) continue
+        const rel = base ? `${base}/${entry.name}` : entry.name
+        if (entry.isDirectory()) {
+          walk(full, rel)
+        } else if (entry.isFile()) {
+          add(full, rel)
+        }
+      }
+    }
+    walk(targetPath, '')
+  } else if (stat.isFile()) {
+    add(targetPath, basename(targetPath))
+    const parent = dirname(targetPath)
+    for (const configName of [
+      'rnx-detox.config.cjs',
+      'jest.config.cjs',
+      'jest.config.js',
+    ]) {
+      const configPath = join(parent, configName)
+      if (existsSync(configPath) && !files[configName]) {
+        add(configPath, configName)
+      }
+    }
+  }
+  const serializedBytes = Buffer.byteLength(JSON.stringify(files))
+  if (serializedBytes > RNX_CLOUD_TEST_FILES_MAX_BYTES) {
+    throw new Error(
+      `cloud test files serialize to ${serializedBytes} bytes; the limit is ${RNX_CLOUD_TEST_FILES_MAX_BYTES}`,
+    )
+  }
+  return files
+}
+
+export async function runCloudTest(
+  args: string[],
+  opts: RunTestOptions = {},
+): Promise<number> {
+  const forwarded = args.filter((a) => a !== '--cloud' && a !== '--hosted')
+  const originFlag = valueAfter(forwarded, '--origin')
+  const origin = await resolveDefaultUploadOrigin(originFlag ?? undefined)
+  const app =
+    valueAfter(forwarded, '--app') ||
+    valueAfter(forwarded, '--bundle') ||
+    valueAfter(forwarded, '--bundle-url') ||
+    valueAfter(forwarded, '--url') ||
+    forwarded.find((a) => a.startsWith('--app='))?.split('=')[1] ||
+    forwarded.find((a) => a.startsWith('--bundle='))?.split('=')[1] ||
+    forwarded.find((a) => a.startsWith('--url='))?.split('=')[1]
+
+  const owner = valueAfter(forwarded, '--owner')
+  const repo = valueAfter(forwarded, '--repo')
+
+  let target = targetFromArgs(forwarded)
+  const config = valueAfter(forwarded, '--config')
+  if (!target && config) {
+    target = config
+  }
+  if (!target) {
+    for (const cand of ['.maestro', 'maestro', 'flows', 'e2e']) {
+      if (existsSync(resolve(process.cwd(), cand))) {
+        target = cand
+        break
+      }
+    }
+  }
+  if (!target) {
+    console.error('  usage: rnx test <flow-or-suite> --app <bundle> --cloud')
+    return 1
+  }
+
+  const targetPath = resolve(process.cwd(), target)
+  if (!existsSync(targetPath)) {
+    console.error(`  error: test target not found: ${target}`)
+    return 1
+  }
+
+  if (!app) {
+    console.error(
+      '  error: rnx test --cloud requires --app <bundle.js|https://bundle-url>',
+    )
+    return 1
+  }
+
+  const auth = resolveCliAuth()
+  if (!auth) {
+    console.error('  error: rnx test --cloud requires `rnx login` or RNX_API_KEY')
+    return 1
+  }
+
+  const pollIntervalFlag = valueAfter(forwarded, '--poll-interval')
+  const timeoutFlag = valueAfter(forwarded, '--timeout')
+  const pollIntervalMs =
+    pollIntervalFlag === null ? (opts.pollIntervalMs ?? 1000) : Number(pollIntervalFlag)
+  const timeoutMs =
+    timeoutFlag === null ? (opts.timeoutMs ?? 20 * 60 * 1000) : Number(timeoutFlag)
+  if (!Number.isFinite(pollIntervalMs) || pollIntervalMs < 1) {
+    console.error('  error: --poll-interval must be a positive number of milliseconds')
+    return 1
+  }
+  if (!Number.isFinite(timeoutMs) || timeoutMs < 1) {
+    console.error('  error: --timeout must be a positive number of milliseconds')
+    return 1
+  }
+
+  let bundleUrl: string | undefined
+  let bundle: string | undefined
+  let bundleShareId: string | undefined
+
+  if (app.startsWith('http://') || app.startsWith('https://')) {
+    bundleUrl = app
+  } else if (app.startsWith('srb_') || app.includes('/api/preview/share/bundle')) {
+    bundleShareId = app.replace(/^.*id=/, '')
+  } else {
+    const localBundle = resolve(process.cwd(), app)
+    if (!existsSync(localBundle) || !statSync(localBundle).isFile()) {
+      console.error(`  error: --app bundle file not found: ${app}`)
+      return 1
+    }
+    bundle = readFileSync(localBundle, 'utf8')
+  }
+
+  const targetName = basename(targetPath)
+  const collectionPath =
+    statSync(targetPath).isFile() &&
+    (/^(?:jest|rnx-detox)\.config\.[cm]?[jt]s$|^jest\.config\.json$/.test(targetName) ||
+      /\.[cm]?[jt]sx?$/.test(extname(targetPath)))
+      ? dirname(targetPath)
+      : targetPath
+  const localBundlePath =
+    app.startsWith('http://') ||
+    app.startsWith('https://') ||
+    app.startsWith('srb_') ||
+    app.includes('/api/preview/share/bundle')
+      ? null
+      : resolve(process.cwd(), app)
+  const testFiles = collectTestFiles(collectionPath, localBundlePath)
+  if (Object.keys(testFiles).length === 0) {
+    console.error(`  error: no test files found at ${target}`)
+    return 1
+  }
+
+  const submitPayload: Record<string, unknown> = {
+    kind: 'test',
+    testFiles,
+  }
+  if (bundleUrl) submitPayload.bundleUrl = bundleUrl
+  if (bundle) submitPayload.bundle = bundle
+  if (bundleShareId) submitPayload.bundleShareId = bundleShareId
+  if (owner) submitPayload.owner = owner
+  if (repo) submitPayload.repo = repo
+
+  const endpoint = `${origin.replace(/\/$/, '')}/api/sootsim/runner/jobs`
+  let response: Response
+  try {
+    response = await fetch(endpoint, {
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        authorization: authHeaderValue(auth),
+      },
+      body: JSON.stringify(submitPayload),
+    })
+  } catch (err) {
+    console.error(
+      `  error: could not connect to ${endpoint}: ${err instanceof Error ? err.message : String(err)}`,
+    )
+    return 1
+  }
+
+  if (!response.ok) {
+    const body = await response.text()
+    let message = body
+    try {
+      const json = JSON.parse(body)
+      if (json.message) message = json.message
+    } catch {}
+    console.error(
+      `  error: cloud test submission failed (${response.status}): ${message}`,
+    )
+    return 1
+  }
+
+  const { id } = (await response.json()) as { id: string }
+  console.log(`  cloud test job submitted: ${id}`)
+
+  const pollUrl = `${origin.replace(/\/$/, '')}/api/sootsim/runner/jobs?id=${encodeURIComponent(id)}`
+  const startedAt = Date.now()
+
+  while (Date.now() - startedAt < timeoutMs) {
+    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs))
+    let pollRes: Response
+    try {
+      pollRes = await fetch(pollUrl, {
+        headers: { authorization: authHeaderValue(auth) },
+      })
+    } catch (err) {
+      console.warn(
+        `  warn: error polling job: ${err instanceof Error ? err.message : String(err)}`,
+      )
+      continue
+    }
+    if (!pollRes.ok) {
+      console.warn(`  warn: polling error: HTTP ${pollRes.status}`)
+      continue
+    }
+    const job = (await pollRes.json()) as {
+      id: string
+      status: string
+      result?: {
+        previewId?: string | null
+        previewUrl?: string | null
+        runId?: string | null
+        exitCode?: number | null
+        failureReason?: string | null
+      } | null
+    }
+
+    if (job.status === 'done' || job.status === 'failed' || job.status === 'expired') {
+      const result = job.result
+      // a job the recorder failed after a passing suite (missing recording or
+      // registration) is still a failed run.
+      const exitCode =
+        job.status === 'done' ? (result?.exitCode ?? 0) : result?.exitCode || 1
+      console.log(`  status:    ${job.status}`)
+      console.log(`  exit code: ${exitCode}`)
+      if (result?.previewUrl) {
+        console.log(`  preview:   ${result.previewUrl}`)
+      } else if (result?.previewId) {
+        console.log(
+          `  preview:   ${origin.replace(/\/$/, '')}/preview/${result.previewId}`,
+        )
+      }
+      if (result?.runId) {
+        console.log(`  run:       ${result.runId}`)
+      }
+      if (result?.failureReason) {
+        console.error(`  failure:   ${result.failureReason}`)
+      }
+      return exitCode
+    }
+  }
+
+  console.error(`  error: cloud test timed out after ${Math.round(timeoutMs / 1000)}s`)
+  return 1
+}
+
+export async function runTest(
+  args: string[],
+  opts: RunTestOptions = {},
+): Promise<number> {
+  if (args.includes('--cloud') || args.includes('--hosted')) {
+    return runCloudTest(args, opts)
+  }
+
+  const selected = resolveTestCommand(args)
+  const app = valueAfter(args, '--app')
+  const appTarget = app
+    ? await resolveTestAppTarget(app)
+    : { target: '', close: async () => {} }
+
+  try {
+    if (selected.command === 'maestro') {
+      const { flowTimeoutScale } = await import('../../src/flow-timeout-scale')
+      if (flowTimeoutScale() !== 1) {
+        throw new Error(
+          'rnx test requires original flow timeouts; unset SOOTSIM_FLOW_TIMEOUT_SCALE',
+        )
+      }
+      const { runMaestro } = await import('./maestro')
+      const maestroArgs = appTarget.target
+        ? selected.args.map((arg, idx) => {
+            const prev = selected.args[idx - 1]
+            if (prev === '--url') return appTarget.target
+            if (arg.startsWith('--url=')) return `--url=${appTarget.target}`
+            return arg
+          })
+        : selected.args
+      const code = await runMaestro(maestroArgs, opts)
+      return typeof code === 'number' ? code : 0
+    }
+
+    const { runDetox } = await import('./detox')
+    const detoxArgs = withoutApp(selected.args)
+    const previousRnxUrl = process.env.RNX_URL
+    if (appTarget.target) {
+      process.env.RNX_URL = await buildShellUrl(
+        appTarget.target,
+        resolveShellBaseUrlForBridgePort(
+          opts.port ?? (Number(process.env.SOOTSIM_PORT) || 5173),
+        ),
+      )
+    }
+    try {
+      await runDetox(detoxArgs, opts)
+      return 0
+    } finally {
+      if (appTarget.target) {
+        restoreRnxUrl(previousRnxUrl)
+      }
+    }
+  } finally {
+    await appTarget.close()
+  }
+}