feat: attest integration

.gitignore

@@ -28,3 +28,4 @@ test/**/__screenshots__/**/*
 test/browser/fixtures/update-snapshot/basic.test.ts
 test/cli/fixtures/browser-multiple/basic-*
 .vitest-reports
+.attest

packages/snapshot/src/client.ts

@@ -43,6 +43,7 @@ interface AssertOptions {
   error?: Error
   errorMessage?: string
   rawSnapshot?: RawSnapshotInfo
+  skip?: boolean
 }
 
 export interface SnapshotClientOptions {
@@ -102,6 +103,7 @@ export class SnapshotClient {
       error,
       errorMessage,
       rawSnapshot,
+      skip,
     } = options
     let { received } = options
 
@@ -148,6 +150,7 @@ export class SnapshotClient {
       error,
       inlineSnapshot,
       rawSnapshot,
+      skip,
     })
 
     if (!pass) {

packages/snapshot/src/port/inlineSnapshot.ts

@@ -116,23 +116,23 @@ function prepareSnapString(snap: string, source: string, index: number) {
     .replace(/\$\{/g, '\\${')}\n${indent}${quote}`
 }
 
-const toMatchInlineName = 'toMatchInlineSnapshot'
-const toThrowErrorMatchingInlineName = 'toThrowErrorMatchingInlineSnapshot'
+const assertionNames = [
+  'toMatchInlineSnapshot',
+  'toThrowErrorMatchingInlineSnapshot',
+  'toMatchTypeInlineSnapshot',
+  'toMatchTypeErrorInlineSnapshot',
+  'toMatchTypeCompletionInlineSnapshot',
+]
 
 // on webkit, the line number is at the end of the method, not at the start
 function getCodeStartingAtIndex(code: string, index: number) {
-  const indexInline = index - toMatchInlineName.length
-  if (code.slice(indexInline, index) === toMatchInlineName) {
-    return {
-      code: code.slice(indexInline),
-      index: indexInline,
-    }
-  }
-  const indexThrowInline = index - toThrowErrorMatchingInlineName.length
-  if (code.slice(index - indexThrowInline, index) === toThrowErrorMatchingInlineName) {
-    return {
-      code: code.slice(index - indexThrowInline),
-      index: index - indexThrowInline,
+  for (const name of assertionNames) {
+    const indexName = index - name.length
+    if (code.slice(indexName, index) === name) {
+      return {
+        code: code.slice(indexName),
+        index: indexName,
+      }
     }
   }
   return {
@@ -141,8 +141,8 @@ function getCodeStartingAtIndex(code: string, index: number) {
   }
 }
 
-const startRegex
-  = /(?:toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot)\s*\(\s*(?:\/\*[\s\S]*\*\/\s*|\/\/.*(?:[\n\r\u2028\u2029]\s*|[\t\v\f \xA0\u1680\u2000-\u200A\u202F\u205F\u3000\uFEFF]))*[\w$]*(['"`)])/
+const assertionNameRe = new RegExp(assertionNames.join('|'))
+const startRegex = new RegExp(`(?:${assertionNameRe.source})${/\s*\(\s*(?:\/\*[\s\S]*\*\/\s*|\/\/.*(?:[\n\r\u2028\u2029]\s*|[\t\v\f \xA0\u1680\u2000-\u200A\u202F\u205F\u3000\uFEFF]))*[\w$]*(['"`)])/.source}`)
 export function replaceInlineSnap(
   code: string,
   s: MagicString,
@@ -153,9 +153,7 @@ export function replaceInlineSnap(
 
   const startMatch = startRegex.exec(codeStartingAtIndex)
 
-  const firstKeywordMatch = /toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot/.exec(
-    codeStartingAtIndex,
-  )
+  const firstKeywordMatch = codeStartingAtIndex.match(assertionNameRe)
 
   if (!startMatch || startMatch.index !== firstKeywordMatch?.index) {
     return replaceObjectSnap(code, s, index, newSnap)

packages/snapshot/src/port/state.ts

@@ -20,7 +20,6 @@ import type { RawSnapshot, RawSnapshotInfo } from './rawSnapshot'
 import { parseErrorStacktrace } from '../../../utils/src/source-map'
 import { saveInlineSnapshots } from './inlineSnapshot'
 import { saveRawSnapshots } from './rawSnapshot'
-
 import {
   addExtraLineBreaks,
   getSnapshotData,
@@ -235,6 +234,7 @@ export default class SnapshotState {
     isInline,
     error,
     rawSnapshot,
+    skip,
   }: SnapshotMatchOptions): SnapshotReturnOptions {
     this._counters.set(testName, (this._counters.get(testName) || 0) + 1)
     const count = Number(this._counters.get(testName))
@@ -250,6 +250,11 @@ export default class SnapshotState {
       this._uncheckedKeys.delete(key)
     }
 
+    // allow no-op snapshot assertion for attest
+    if (skip) {
+      return { pass: true, actual: '', key, count }
+    }
+
     let receivedSerialized
       = rawSnapshot && typeof received === 'string'
         ? (received as string)

packages/snapshot/src/types/index.ts

@@ -31,6 +31,7 @@ export interface SnapshotMatchOptions {
   isInline: boolean
   error?: Error
   rawSnapshot?: RawSnapshotInfo
+  skip?: boolean
 }
 
 export interface SnapshotResult {

packages/vitest/package.json

@@ -122,6 +122,7 @@
     "dev": "NODE_OPTIONS=\"--max-old-space-size=8192\" rollup -c --watch -m inline"
   },
   "peerDependencies": {
+    "@ark/attest": "*",
     "@edge-runtime/vm": "*",
     "@types/node": "^18.0.0 || >=20.0.0",
     "@vitest/browser": "workspace:*",
@@ -130,6 +131,9 @@
     "jsdom": "*"
   },
   "peerDependenciesMeta": {
+    "@ark/attest": {
+      "optional": true
+    },
     "@edge-runtime/vm": {
       "optional": true
     },
@@ -174,6 +178,7 @@
   "devDependencies": {
     "@ampproject/remapping": "^2.3.0",
     "@antfu/install-pkg": "^0.4.1",
+    "@ark/attest": "^0.28.0",
     "@edge-runtime/vm": "^4.0.4",
     "@sinonjs/fake-timers": "11.1.0",
     "@types/debug": "^4.1.12",

packages/vitest/src/integrations/attest/node.ts

@@ -0,0 +1,18 @@
+import type { TestProject } from '../../node/project'
+import { mkdirSync } from 'node:fs'
+import path from 'node:path'
+
+export async function attestGlobalSetup(project: TestProject) {
+  process.env.ATTEST_attestAliases = JSON.stringify(['attest', 'expect'])
+
+  const { writeAssertionData } = await import('@ark/attest')
+  const filepath = path.join(project.config.root, '.attest/assertions/typescript.json')
+  mkdirSync(path.dirname(filepath), { recursive: true })
+
+  function precache(): void {
+    return writeAssertionData(filepath)
+  }
+
+  precache()
+  project.onTestsRerun(() => precache())
+}

packages/vitest/src/integrations/attest/runtime.ts

@@ -0,0 +1,220 @@
+import type { ChaiPlugin } from '@vitest/expect'
+import type {
+  Plugin as PrettyFormatPlugin,
+} from '@vitest/pretty-format'
+import type { SerializedConfig } from '../../runtime/config'
+import { addSerializer, stripSnapshotIndentation } from '@vitest/snapshot'
+import { parseStacktrace } from '@vitest/utils/source-map'
+import * as chai from 'chai'
+import { getSnapshotClient, getTestNames } from '../snapshot/chai'
+
+// lazy load '@ark/attest` only when enabled
+// TODO: can we read file .attest on our own? this is used only for `getTypeAssertionsAtPosition`.
+// TODO: importing '@ark/attest' pulls entire 'typescript', so that should be avoided on runtime.
+let lib: typeof import('@ark/attest')
+let enabled = false
+
+const attestChai: ChaiPlugin = (chai, utils) => {
+  function getTypeAssertions(ctx: object) {
+    const parsed = parseStacktrace(utils.flag(ctx, '__vitest_expect_stack'))
+    const location = parsed[0]
+    const types = lib.getTypeAssertionsAtPosition({
+      file: location.file,
+      method: location.method,
+      line: location.line,
+      char: location.column,
+    })
+    return types
+  }
+
+  function setupOptions(ctx: object, name: string) {
+    utils.flag(ctx, '_name', name)
+    const isNot = utils.flag(ctx, 'negate')
+    if (isNot) {
+      throw new Error(`"${name}" cannot be used with "not"`)
+    }
+    const test = utils.flag(ctx, 'vitest-test')
+    const options = getTestNames(test)
+    return {
+      skip: !enabled,
+      error: utils.flag(ctx, 'error'),
+      errorMessage: utils.flag(ctx, 'message'),
+      ...options,
+    }
+  }
+
+  utils.addMethod(
+    chai.Assertion.prototype,
+    'toMatchTypeSnapshot',
+    function (
+      this: Record<string, unknown>,
+      message?: string,
+    ) {
+      const options = setupOptions(this, 'toMatchTypeSnapshot')
+      let value: any
+      if (enabled) {
+        const types = getTypeAssertions(this)
+        value = types[0][1].args[0].type
+      }
+      getSnapshotClient().assert({
+        received: new AttestSnapshotWrapper(value),
+        message,
+        ...options,
+      })
+    },
+  )
+  utils.addMethod(
+    chai.Assertion.prototype,
+    'toMatchTypeInlineSnapshot',
+    function __INLINE_SNAPSHOT__(
+      this: Record<string, unknown>,
+      inlineSnapshot?: string,
+      message?: string,
+    ) {
+      const assertOptions = setupOptions(this, 'toMatchTypeInlineSnapshot')
+      if (inlineSnapshot) {
+        inlineSnapshot = stripSnapshotIndentation(inlineSnapshot)
+      }
+      let value: any
+      if (enabled) {
+        const types = getTypeAssertions(this)
+        value = types[0][1].args[0].type
+      }
+      getSnapshotClient().assert({
+        received: new AttestSnapshotWrapper(value),
+        message,
+        isInline: true,
+        inlineSnapshot,
+        ...assertOptions,
+      })
+    },
+  )
+  utils.addMethod(
+    chai.Assertion.prototype,
+    'toMatchTypeErrorSnapshot',
+    function (
+      this: Record<string, unknown>,
+      message?: string,
+    ) {
+      const options = setupOptions(this, 'toMatchTypeErrorSnapshot')
+      let value: any
+      if (enabled) {
+        const types = getTypeAssertions(this)
+        value = types[0][1].errors[0]
+      }
+      getSnapshotClient().assert({
+        received: new AttestSnapshotWrapper(value),
+        message,
+        ...options,
+      })
+    },
+  )
+  utils.addMethod(
+    chai.Assertion.prototype,
+    'toMatchTypeErrorInlineSnapshot',
+    function __INLINE_SNAPSHOT__(
+      this: Record<string, unknown>,
+      inlineSnapshot?: string,
+      message?: string,
+    ) {
+      const assertOptions = setupOptions(this, 'toMatchTypeErrorInlineSnapshot')
+      if (inlineSnapshot) {
+        inlineSnapshot = stripSnapshotIndentation(inlineSnapshot)
+      }
+      let value: any
+      if (enabled) {
+        const types = getTypeAssertions(this)
+        value = types[0][1].errors[0]
+      }
+      getSnapshotClient().assert({
+        received: new AttestSnapshotWrapper(value),
+        message,
+        isInline: true,
+        inlineSnapshot,
+        ...assertOptions,
+      })
+    },
+  )
+  utils.addMethod(
+    chai.Assertion.prototype,
+    'toMatchTypeCompletionSnapshot',
+    function (
+      this: Record<string, unknown>,
+      message?: string,
+    ) {
+      const options = setupOptions(this, 'toMatchTypeCompletionSnapshot')
+      let value: any
+      if (enabled) {
+        const types = getTypeAssertions(this)
+        value = types[0][1].completions
+      }
+      getSnapshotClient().assert({
+        received: new AttestSnapshotWrapper(value),
+        message,
+        ...options,
+      })
+    },
+  )
+  utils.addMethod(
+    chai.Assertion.prototype,
+    'toMatchTypeCompletionInlineSnapshot',
+    function __INLINE_SNAPSHOT__(
+      this: Record<string, unknown>,
+      inlineSnapshot?: string,
+      message?: string,
+    ) {
+      const assertOptions = setupOptions(this, 'toMatchTypeCompletionInlineSnapshot')
+      if (inlineSnapshot) {
+        inlineSnapshot = stripSnapshotIndentation(inlineSnapshot)
+      }
+      let value: any
+      if (enabled) {
+        const types = getTypeAssertions(this)
+        value = types[0][1].completions
+      }
+      getSnapshotClient().assert({
+        received: new AttestSnapshotWrapper(value),
+        message,
+        isInline: true,
+        inlineSnapshot,
+        ...assertOptions,
+      })
+    },
+  )
+}
+
+class AttestSnapshotWrapper {
+  constructor(public value?: unknown) {}
+}
+
+const attestPrettyFormat: PrettyFormatPlugin = {
+  test(val: unknown) {
+    return !!(val && val instanceof AttestSnapshotWrapper)
+  },
+  serialize(val: AttestSnapshotWrapper, config, indentation, depth, refs, printer) {
+    if (typeof val.value === 'string') {
+      return val.value
+    }
+    return printer(
+      val.value,
+      config,
+      indentation,
+      depth,
+      refs,
+    )
+  },
+}
+
+export async function attestSetup(config: SerializedConfig) {
+  chai.use(attestChai)
+  addSerializer(attestPrettyFormat)
+  enabled = config.attest
+  if (enabled) {
+    lib = await import('@ark/attest')
+  }
+  else {
+    if (typeof process !== 'undefined') {
+      process.env.ATTEST_skipTypes = 'true'
+    }
+  }
+}