@weft-js/cli 0.1.1 → 0.1.3

package/src/test-rules/syntax.mjs

@@ -0,0 +1,223 @@
+import { existsSync } from 'node:fs'
+import ts from 'typescript'
+import { local } from '../alias.mjs'
+
+const suiteRoots = new Set(['describe', 'suite', 'fdescribe', 'xdescribe'])
+const testRoots = new Set(['test', 'it', 'fit', 'xit', 'xtest', ...suiteRoots])
+const exts = [
+  '',
+  '.ts',
+  '.tsx',
+  '.mts',
+  '.js',
+  '.jsx',
+  '.mjs',
+  '/index.ts',
+  '/index.tsx',
+  '/index.js',
+]
+
+const kindOf = (file) =>
+  file.endsWith('.tsx')
+    ? ts.ScriptKind.TSX
+    : file.endsWith('.jsx')
+      ? ts.ScriptKind.JSX
+      : /\.[mc]?ts$/.test(file)
+        ? ts.ScriptKind.TS
+        : ts.ScriptKind.JS
+export const parse = (text, file) =>
+  ts.createSourceFile(file, text, ts.ScriptTarget.Latest, true, kindOf(file))
+export const isFn = (n) =>
+  n && (ts.isArrowFunction(n) || ts.isFunctionExpression(n) || ts.isFunctionDeclaration(n))
+export const norm = (n) => n.getText().replace(/\s+/g, ' ').replace(/;$/, '')
+export const unwrap = (n) => {
+  while (
+    n &&
+    (ts.isParenthesizedExpression(n) ||
+      ts.isAsExpression(n) ||
+      ts.isNonNullExpression(n) ||
+      ts.isAwaitExpression(n))
+  )
+    n = n.expression
+  return n
+}
+
+export function walk(node, visit) {
+  const go = (n) => {
+    if (visit(n) === false) return
+    ts.forEachChild(n, go)
+  }
+  go(node)
+}
+
+export const contains = (node, pred) => {
+  let hit = false
+  walk(node, (n) => {
+    if (hit) return false
+    if (pred(n)) hit = true
+  })
+  return hit
+}
+
+/** The identifier at the root of `a.b(…).c`, or undefined. */
+export function rootName(expr) {
+  let n = expr
+  for (;;) {
+    n = unwrap(n)
+    if (
+      ts.isPropertyAccessExpression(n) ||
+      ts.isElementAccessExpression(n) ||
+      ts.isCallExpression(n)
+    )
+      n = n.expression
+    else break
+  }
+  return ts.isIdentifier(n) ? n.text : undefined
+}
+
+/** `1`, `'a'`, `null`, `[1, { a: 'b' }]`: a value with nothing behind it. */
+export function isLiteral(n) {
+  n = unwrap(n)
+  if (!n) return false
+  if (
+    ts.isStringLiteral(n) ||
+    ts.isNumericLiteral(n) ||
+    ts.isBigIntLiteral(n) ||
+    ts.isNoSubstitutionTemplateLiteral(n) ||
+    ts.isRegularExpressionLiteral(n)
+  )
+    return true
+  if (
+    [ts.SyntaxKind.TrueKeyword, ts.SyntaxKind.FalseKeyword, ts.SyntaxKind.NullKeyword].includes(
+      n.kind,
+    )
+  )
+    return true
+  if (ts.isIdentifier(n)) return n.text === 'undefined' || n.text === 'NaN' || n.text === 'Infinity'
+  if (ts.isPrefixUnaryExpression(n)) return isLiteral(n.operand)
+  if (ts.isArrayLiteralExpression(n)) return n.elements.every(isLiteral)
+  if (ts.isObjectLiteralExpression(n))
+    return n.properties.every((p) => ts.isPropertyAssignment(p) && isLiteral(p.initializer))
+  return false
+}
+
+export const hasCall = (n) =>
+  contains(
+    n,
+    (x) =>
+      ts.isCallExpression(x) ||
+      ts.isNewExpression(x) ||
+      ts.isAwaitExpression(x) ||
+      ts.isTaggedTemplateExpression(x),
+  )
+
+/** `expect(x)`, `expect.soft(x)`, `t.expect(x)`: the call that takes the subject. */
+export function isSubject(call) {
+  const c = call.expression
+  if (ts.isIdentifier(c)) return c.text === 'expect'
+  if (!ts.isPropertyAccessExpression(c)) return false
+  if (c.name.text === 'expect') return true
+  return (
+    ts.isIdentifier(c.expression) &&
+    c.expression.text === 'expect' &&
+    ['soft', 'poll'].includes(c.name.text)
+  )
+}
+
+/** For a subject call, the matcher it ends in: `expect(x).not.toBe(1)` → { name: 'toBe', call, not: true }. */
+export function matcherOf(subject) {
+  let cur = subject
+  let not = false
+  const mods = []
+  for (;;) {
+    const p = cur.parent
+    if (p && ts.isPropertyAccessExpression(p) && p.expression === cur) {
+      const name = p.name.text
+      if (p.parent && ts.isCallExpression(p.parent) && p.parent.expression === p)
+        return { name, node: p.name, call: p.parent, not, mods }
+      if (name === 'not') not = !not
+      mods.push(name)
+      cur = p
+    } else return null
+  }
+}
+
+/** Test and suite calls, with their modifiers: `test.only.each(table)('x', fn)`. */
+export function testCall(call) {
+  // The outer call of a curried form (`test.each(t)(…)`) is the test; skip the inner one.
+  if (call.parent && ts.isCallExpression(call.parent) && call.parent.expression === call)
+    return null
+  const mods = []
+  let n = call.expression
+  for (;;) {
+    if (ts.isPropertyAccessExpression(n)) {
+      mods.unshift({ name: n.name.text, node: n })
+      n = n.expression
+    } else if (ts.isCallExpression(n)) n = n.expression
+    else break
+  }
+  if (!ts.isIdentifier(n) || !testRoots.has(n.text)) return null
+  const root = n.text
+  const fn = [...call.arguments]
+    .reverse()
+    .find((a) => ts.isArrowFunction(a) || ts.isFunctionExpression(a))
+  // `fit` with no test body is someone's function (@weft-js/core/text's), not a focused test
+  if (root === 'fit' && !fn) return null
+  return { root, rootNode: n, mods, fn, suite: suiteRoots.has(root), call }
+}
+
+/** Functions (by name) whose bodies assert, in one file: local helpers and, given `imported`, what they call. */
+export function assertingFunctions(sf, imported = new Set()) {
+  const bodies = new Map()
+  const add = (name, fn) => fn?.body && bodies.set(name, fn.body)
+  for (const st of sf.statements) {
+    const decl = ts.isExportDeclaration(st) ? null : st
+    if (decl && ts.isFunctionDeclaration(decl) && decl.name) add(decl.name.text, decl)
+    if (decl && ts.isVariableStatement(decl))
+      for (const d of decl.declarationList.declarations)
+        if (ts.isIdentifier(d.name) && isFn(d.initializer)) add(d.name.text, d.initializer)
+  }
+  const asserting = new Set(imported)
+  for (let changed = true; changed;) {
+    changed = false
+    for (const [name, body] of bodies) {
+      if (asserting.has(name) || !asserts(body, asserting)) continue
+      asserting.add(name)
+      changed = true
+    }
+  }
+  return asserting
+}
+
+/** Does this code assert? A matcher, `assert…`, `expect.assertions`, a helper named `expect…`, or a known asserting function. */
+export function asserts(node, asserting) {
+  return contains(node, (n) => {
+    if (!ts.isCallExpression(n)) return false
+    if (isSubject(n)) return Boolean(matcherOf(n))
+    const c = n.expression
+    if (
+      ts.isPropertyAccessExpression(c) &&
+      ts.isIdentifier(c.expression) &&
+      c.expression.text === 'expect'
+    )
+      return true // expect.assertions(n)
+    const name = ts.isIdentifier(c)
+      ? c.text
+      : ts.isPropertyAccessExpression(c) && ts.isIdentifier(c.expression)
+        ? c.expression.text
+        : undefined
+    return Boolean(name && (/^(expect|assert)([A-Z_]|$)/.test(name) || asserting.has(name)))
+  })
+}
+
+export function resolveImport(fromAbs, spec) {
+  const base = local(fromAbs, spec)
+  if (!base) return null
+  for (const e of exts) {
+    const p = base + e
+    if (existsSync(p) && !p.endsWith('/') && (e || /\.[cm]?[jt]sx?$/.test(p))) return p
+  }
+  return null
+}
+
+export const moduleKey = (abs) => abs.replace(/(\/index)?\.[cm]?[jt]sx?$/, '')

package/src/test-rules/test-rules.mjs

@@ -0,0 +1,127 @@
+import ts from 'typescript'
+import { asserts, isSubject, matcherOf, norm, walk } from './syntax.mjs'
+import { assertsWhatItSet, conditional } from './rule-helpers.mjs'
+
+const focusRoots = { fit: 'it', fdescribe: 'describe' }
+const skipRoots = { xit: 'it', xtest: 'test', xdescribe: 'describe' }
+
+export function focusRule(t, { sf, edit, report }) {
+  const focus =
+    t.mods.find((m) => m.name === 'only') ??
+    (focusRoots[t.root] && { name: 'only', node: t.rootNode })
+  const skip =
+    t.mods.find((m) => m.name === 'skip') ??
+    (skipRoots[t.root] && { name: 'skip', node: t.rootNode })
+  for (const m of [focus, skip].filter(Boolean)) {
+    const kind = t.suite ? 'suite' : 'test'
+    let fix
+    if (m.node === t.rootNode) {
+      const to = focusRoots[t.root] ?? skipRoots[t.root]
+      fix = {
+        description: `Rename \`${t.root}\` to \`${to}\``,
+        safe: m.name === 'only',
+        edits: [edit(m.node.getStart(sf), m.node.getEnd(), to)],
+      }
+      report(
+        'T009',
+        m.node,
+        `\`${t.root}\` ${m.name === 'only' ? 'focuses this ' + kind + ': every other test in the run is silently skipped' : 'skips this ' + kind + ': it never runs, so it proves nothing'}.`,
+        { fix },
+      )
+    } else {
+      const dot = m.node.expression.getEnd()
+      fix = {
+        description: `Remove \`.${m.name}\``,
+        safe: m.name === 'only',
+        edits: [edit(dot, m.node.getEnd(), '')],
+      }
+      report(
+        'T009',
+        m.node.name,
+        m.name === 'only'
+          ? `\`.only\` focuses this ${kind}: every other test in the run is silently skipped.`
+          : `\`.skip\` turns this ${kind} off: it never runs, so it proves nothing. Fix or delete it; a test that is meant to fail is \`test.fails\`.`,
+        { fix },
+      )
+    }
+  }
+}
+
+function assertionRule(t, { asserting, report }, n, previouslyNoAssertion) {
+  if (n) {
+    if (!previouslyNoAssertion)
+      report('T001', n, `\`${norm(n)}\` has no matcher, so it asserts nothing.`, {
+        help: 'Finish it: `expect(x).toBe(…)`, `.toHaveTextContent(…)`, …',
+      })
+    return
+  }
+  const body = t.fn.body
+  const noAssertion = !asserts(body, asserting)
+  if (noAssertion) {
+    const title =
+      t.call.arguments[0] && ts.isStringLiteralLike(t.call.arguments[0])
+        ? ` "${t.call.arguments[0].text}"`
+        : ''
+    report(
+      'T001',
+      t.call.expression,
+      `Test${title} makes no assertion: it passes as long as nothing throws.`,
+    )
+  }
+
+  return noAssertion
+}
+
+function conditionalRule(t, ctx, noAssertion) {
+  const { report } = ctx
+  const body = t.fn.body
+  // A looped `expect` is fine next to one that always runs; a conditional one never is.
+  const looped = []
+  let always = false
+  walk(body, (n) => {
+    if (!ts.isCallExpression(n) || !isSubject(n)) return
+    const m = matcherOf(n)
+    if (!m) {
+      assertionRule(t, ctx, n, noAssertion)
+      return
+    }
+    let why
+    for (let a = n.parent; a && a !== t.fn && !why; a = a.parent) why = conditional(a, n)
+    if (!why) always = true
+    else if (why.loop) looped.push([m.call, why.text])
+    else
+      report(
+        'T008',
+        m.call,
+        `This \`expect\` only runs ${why.text}, so the test can pass without checking anything.`,
+      )
+  })
+  if (!always)
+    for (const [call, how] of looped)
+      report(
+        'T008',
+        call,
+        `Every \`expect\` in this test runs ${how}, so the test can pass without checking anything.`,
+      )
+}
+
+export function setRule(t, { report }) {
+  const body = t.fn.body
+  if (ts.isBlock(body)) assertsWhatItSet(body.statements, report)
+}
+
+export const testRules = [focusRule, assertionRule, conditionalRule, setRule]
+
+export function runTestRules(t, ctx) {
+  testRules[0](t, ctx)
+  if (
+    t.suite ||
+    !t.fn ||
+    t.mods.some((m) => ['todo', 'skip'].includes(m.name)) ||
+    skipRoots[t.root]
+  )
+    return
+  const noAssertion = testRules[1](t, ctx)
+  testRules[2](t, ctx, noAssertion)
+  testRules[3](t, ctx)
+}

package/src/testdiff.mjs

@@ -11,11 +11,12 @@ const skipMods = new Set(['skip', 'todo'])
 const skipRoots = new Set(['xit', 'xtest', 'xdescribe'])
 
 /** A case's name as vitest reports it: suite titles and the test title joined by ' > '. */
-const join = names => names.join(' > ')
+const join = (names) => names.join(' > ')
 
 function nameOf(arg) {
   if (!arg) return { name: '<anonymous>', dynamic: true }
-  if (ts.isStringLiteral(arg) || ts.isNoSubstitutionTemplateLiteral(arg)) return { name: arg.text, dynamic: false }
+  if (ts.isStringLiteral(arg) || ts.isNoSubstitutionTemplateLiteral(arg))
+    return { name: arg.text, dynamic: false }
   return { name: arg.getText(), dynamic: true }
 }
 
@@ -31,51 +32,74 @@ export function testCases(text, rel) {
     if (ts.isCallExpression(node)) {
       const t = testCall(node)
       if (t) {
-        const each = t.mods.some(m => m.name === 'each' || m.name === 'for')
+        const each = t.mods.some((m) => m.name === 'each' || m.name === 'for')
         const { name, dynamic: dyn } = nameOf(node.arguments[0])
-        const skip = skipped || skipRoots.has(t.root) || t.mods.some(m => skipMods.has(m.name))
+        const skip = skipped || skipRoots.has(t.root) || t.mods.some((m) => skipMods.has(m.name))
         const isDynamic = dynamic || dyn || each
         if (t.suite) {
-          if (t.fn?.body) ts.forEachChild(t.fn.body, c => visit(c, [...suites, name], skip, isDynamic))
+          if (t.fn?.body)
+            ts.forEachChild(t.fn.body, (c) => visit(c, [...suites, name], skip, isDynamic))
           return
         }
         const asserts = []
         let expected = null
         if (t.fn?.body)
-          walk(t.fn.body, n => {
+          walk(t.fn.body, (n) => {
             if (!ts.isCallExpression(n)) return
             if (isSubject(n)) {
               const m = matcherOf(n)
               if (!m) return
               const subject = n.arguments[0] ? norm(n.arguments[0]) : ''
               const args = m.call.arguments.map(norm).join(', ')
-              asserts.push({ key: `${subject}|${m.not ? 'not.' : ''}${m.name}|${args}`, subject, matcher: m.name, not: m.not, args, line: pos.lineCol(n.getStart(sf))[0] })
-            } else if (ts.isPropertyAccessExpression(n.expression) && ts.isIdentifier(n.expression.expression) && n.expression.expression.text === 'expect' && n.expression.name.text === 'assertions') {
+              asserts.push({
+                key: `${subject}|${m.not ? 'not.' : ''}${m.name}|${args}`,
+                subject,
+                matcher: m.name,
+                not: m.not,
+                args,
+                line: pos.lineCol(n.getStart(sf))[0],
+              })
+            } else if (
+              ts.isPropertyAccessExpression(n.expression) &&
+              ts.isIdentifier(n.expression.expression) &&
+              n.expression.expression.text === 'expect' &&
+              n.expression.name.text === 'assertions'
+            ) {
               expected = Number(n.arguments[0]?.getText()) || null
             }
           })
         out.push({
-          name: join([...suites, name]), line: pos.lineCol(node.getStart(sf))[0], end: pos.lineCol(node.getEnd())[0], body: t.fn?.body ? norm(t.fn.body) : '',
-          skipped: skip, fails: t.mods.some(m => m.name === 'fails'), dynamic: isDynamic, asserts, expected,
+          name: join([...suites, name]),
+          line: pos.lineCol(node.getStart(sf))[0],
+          end: pos.lineCol(node.getEnd())[0],
+          body: t.fn?.body ? norm(t.fn.body) : '',
+          skipped: skip,
+          fails: t.mods.some((m) => m.name === 'fails'),
+          dynamic: isDynamic,
+          asserts,
+          expected,
         })
         return
       }
     }
-    ts.forEachChild(node, c => visit(c, suites, skipped, dynamic))
+    ts.forEachChild(node, (c) => visit(c, suites, skipped, dynamic))
   }
   visit(sf, [], false, false)
   return out
 }
 
 function walk(node, fn) {
-  const go = n => { fn(n); ts.forEachChild(n, go) }
+  const go = (n) => {
+    fn(n)
+    ts.forEachChild(n, go)
+  }
   go(node)
 }
 
 /** The test names in `after` that are new or whose body changed since `before` (null: the file is new). */
 export function changedCases(before, after, rel) {
-  const old = new Map((before == null ? [] : testCases(before, rel)).map(c => [c.name, c]))
-  return testCases(after, rel).filter(c => !c.skipped && old.get(c.name)?.body !== c.body)
+  const old = new Map((before == null ? [] : testCases(before, rel)).map((c) => [c.name, c]))
+  return testCases(after, rel).filter((c) => !c.skipped && old.get(c.name)?.body !== c.body)
 }
 
 /**
@@ -101,7 +125,8 @@ const looser = {
 
 function loosened(a, b) {
   if (a.subject !== b.subject || a.not !== b.not) return false
-  if (a.matcher === 'toThrow' || a.matcher === 'toThrowError') return b.matcher.startsWith('toThrow') && a.args && !b.args
+  if (a.matcher === 'toThrow' || a.matcher === 'toThrowError')
+    return b.matcher.startsWith('toThrow') && a.args && !b.args
   return looser[a.matcher]?.includes(b.matcher) ?? false
 }
 
@@ -113,16 +138,30 @@ export function weakened(before, after, rel) {
   if (before == null) return []
   const old = testCases(before, rel)
   if (after == null) {
-    const live = old.filter(c => !c.skipped)
-    return live.length ? [t020(rel, null, 1, `${rel} was deleted with ${live.length} test${live.length > 1 ? 's' : ''} in it (${live.slice(0, 3).map(c => `"${c.name}"`).join(', ')}${live.length > 3 ? ', …' : ''})`)] : []
+    const live = old.filter((c) => !c.skipped)
+    return live.length
+      ? [
+          t020(
+            rel,
+            null,
+            1,
+            `${rel} was deleted with ${live.length} test${live.length > 1 ? 's' : ''} in it (${live
+              .slice(0, 3)
+              .map((c) => `"${c.name}"`)
+              .join(', ')}${live.length > 3 ? ', …' : ''})`,
+          ),
+        ]
+      : []
   }
   const sf = parse(after, rel)
   const allowed = allowances(after, sf)
   const now = testCases(after, rel)
-  const byName = new Map(now.map(c => [c.name, c]))
-  const byBody = new Set(now.map(c => c.body))
+  const byName = new Map(now.map((c) => [c.name, c]))
+  const byBody = new Set(now.map((c) => c.body))
   const out = []
-  const report = (line, why) => { if (!allowed('T020', line)) out.push(t020(rel, after, line, why)) }
+  const report = (line, why) => {
+    if (!allowed('T020', line)) out.push(t020(rel, after, line, why))
+  }
   for (const o of old) {
     if (o.skipped || o.dynamic) continue
     const n = byName.get(o.name)
@@ -130,20 +169,40 @@ export function weakened(before, after, rel) {
       if (!byBody.has(o.body)) report(1, `test "${o.name}" was deleted`)
       continue
     }
-    if (n.skipped) { report(n.line, `test "${o.name}" is now skipped`); continue }
-    if (n.fails && !o.fails) { report(n.line, `test "${o.name}" is now marked \`.fails\``); continue }
-    if (o.expected && (n.expected ?? 0) < o.expected) report(n.line, `test "${o.name}" now expects ${n.expected ?? 'no'} assertions instead of ${o.expected}`)
-    const nowKeys = new Set(n.asserts.map(a => a.key))
-    const oldKeys = new Set(o.asserts.map(a => a.key))
-    const gone = o.asserts.filter(a => !nowKeys.has(a.key))
-    const added = n.asserts.filter(a => !oldKeys.has(a.key))
+    if (n.skipped) {
+      report(n.line, `test "${o.name}" is now skipped`)
+      continue
+    }
+    if (n.fails && !o.fails) {
+      report(n.line, `test "${o.name}" is now marked \`.fails\``)
+      continue
+    }
+    if (o.expected && (n.expected ?? 0) < o.expected)
+      report(
+        n.line,
+        `test "${o.name}" now expects ${n.expected ?? 'no'} assertions instead of ${o.expected}`,
+      )
+    const nowKeys = new Set(n.asserts.map((a) => a.key))
+    const oldKeys = new Set(o.asserts.map((a) => a.key))
+    const gone = o.asserts.filter((a) => !nowKeys.has(a.key))
+    const added = n.asserts.filter((a) => !oldKeys.has(a.key))
     for (const a of gone) {
-      const loose = added.find(b => loosened(a, b))
-      if (loose) report(loose.line, `in "${o.name}", \`expect(${a.subject}).${a.not ? 'not.' : ''}${a.matcher}(${a.args})\` became \`${loose.not ? 'not.' : ''}${loose.matcher}(${loose.args})\`, which accepts more`)
+      const loose = added.find((b) => loosened(a, b))
+      if (loose)
+        report(
+          loose.line,
+          `in "${o.name}", \`expect(${a.subject}).${a.not ? 'not.' : ''}${a.matcher}(${a.args})\` became \`${loose.not ? 'not.' : ''}${loose.matcher}(${loose.args})\`, which accepts more`,
+        )
     }
-    const replaced = gone.filter(a => !added.some(b => loosened(a, b)))
+    const replaced = gone.filter((a) => !added.some((b) => loosened(a, b)))
     if (n.asserts.length < o.asserts.length && replaced.length)
-      report(n.line, `"${o.name}" lost ${o.asserts.length - n.asserts.length} assertion${o.asserts.length - n.asserts.length > 1 ? 's' : ''}: ${replaced.slice(0, 2).map(a => `\`expect(${a.subject}).${a.matcher}(…)\``).join(', ')}`)
+      report(
+        n.line,
+        `"${o.name}" lost ${o.asserts.length - n.asserts.length} assertion${o.asserts.length - n.asserts.length > 1 ? 's' : ''}: ${replaced
+          .slice(0, 2)
+          .map((a) => `\`expect(${a.subject}).${a.matcher}(…)\``)
+          .join(', ')}`,
+      )
   }
   return out
 }
@@ -151,7 +210,10 @@ export function weakened(before, after, rel) {
 function t020(rel, _text, line, why) {
   const span = [line, 1, line, 1]
   return diagnostic({
-    code: 'T020', file: rel, span, why: `${why}. An existing test got weaker, so it may no longer catch what it used to.`,
+    code: 'T020',
+    file: rel,
+    span,
+    why: `${why}. An existing test got weaker, so it may no longer catch what it used to.`,
     help: 'Restore it; or, when the change really is intended (the old test pinned a bug), keep it with `// weft-allow T020: <reason>` on that test, where the reviewer sees it',
   })
 }