@plugjs/expect5 0.4.6 → 0.4.8

package/src/expectation/print.ts

@@ -8,7 +8,7 @@ import {
   type MissingValueDiff,
   type ObjectDiff,
 } from './diff'
-import { stringifyValue } from './types'
+import { isMatcher, stringifyValue } from './types'
 
 /* ========================================================================== *
  * CONSTANT LABELS FOR PRINTING                                               *
@@ -31,6 +31,7 @@ const _hellip = $gry('\u2026')
 
 const _error = `${_opnPar}${$gry($und('error'))}${_clsPar}`
 const _string = `${_opnPar}${$gry($und('string'))}${_clsPar}`
+const _matcher = $gry('\u2026 matcher \u2026')
 const _extraProps = $gry('\u2026 extra props \u2026')
 const _diffHeader = `${$wht('Differences')} ${_opnPar}${$red('actual')}${_slash}${$grn('expected')}${_slash}${$ylw('errors')}${_clsPar}:`
 
@@ -270,6 +271,11 @@ function dumpAndContinue(
     return `${prefix}${color(stringify(value))}${suffix}`
   }
 
+  // matchers are a very special value...
+  if (isMatcher(value)) {
+    return `${prefix}${_matcher}${suffix}`
+  }
+
   // check for circular dependencies
   const circular = stack.indexOf(value)
   if (circular >= 0) {

package/src/expectation/types.ts

@@ -1,6 +1,6 @@
 import { type Diff } from './diff'
 import { type Expectations } from './expectations'
-import { type Matchers } from './matchers'
+import { type Matcher } from './matchers'
 
 /* ========================================================================== *
  * INTERNAL TYPES FOR EXPECTATIONS                                            *
@@ -194,7 +194,7 @@ export function prefixType(type: TypeName): string {
 
 export const matcherMarker = Symbol.for('plugjs:expect5:types:Matcher')
 
-export function isMatcher(what: any): what is Matchers {
+export function isMatcher(what: any): what is Matcher {
   return what && what[matcherMarker] === matcherMarker
 }
 

package/src/test.ts

@@ -6,7 +6,7 @@ import { AssertionError } from 'node:assert'
 import { BuildFailure } from '@plugjs/plug'
 import { assert } from '@plugjs/plug/asserts'
 import { type Files } from '@plugjs/plug/files'
-import { $blu, $grn, $gry, $ms, $red, $wht, $ylw, ERROR, NOTICE, WARN, log, type Logger } from '@plugjs/plug/logging'
+import { $blu, $grn, $gry, $ms, $red, $wht, $ylw, ERROR, NOTICE, WARN, log, type Logger, $p, githubAnnotation } from '@plugjs/plug/logging'
 import { type Context, type PipeParameters, type Plug } from '@plugjs/plug/pipe'
 
 import * as setup from './execution/setup'
@@ -15,7 +15,7 @@ import { runSuite } from './execution/executor'
 import { diff } from './expectation/diff'
 import { expect } from './expectation/expect'
 import { printDiff } from './expectation/print'
-import { ExpectationError, stringifyObjectType, stringifyValue } from './expectation/types'
+import { ExpectationError, stringifyValue } from './expectation/types'
 
 import { type TestOptions } from './index'
 
@@ -63,7 +63,11 @@ export class Test implements Plug<void> {
 
     // Create our _root_ Suite
     const suite = new Suite(undefined, '', async () => {
-      for (const file of files.absolutePaths()) await import(file)
+      let count = 0
+      for (const file of files.absolutePaths()) {
+        log.debug('Importing', $p(file), 'in suite', $gry(`(${++ count}/${files.length})`))
+        await import(file)
+      }
     })
 
     // Setup our suite counts
@@ -102,11 +106,15 @@ export class Test implements Plug<void> {
 
     execution.on('spec:skip', (spec, ms) => {
       if (suite.flag === 'only') return context.log.leave()
-      context.log.leave(WARN, `${$ylw(_pending)} ${spec.name} ${$ms(ms)} ${$gry('[')}${$ylw('skipped')}${$gry(']')}`)
+      context.log.leave(WARN, `${$ylw(_pending)} ${spec.name} ${$ms(ms, $ylw('skipped'))}`)
     })
 
     execution.on('spec:pass', (spec, ms) => {
-      context.log.leave(NOTICE, `${$grn(_success)} ${spec.name} ${$ms(ms)}`)
+      if (ms >= (spec.timeout * 0.75)) {
+        context.log.leave(WARN, `${$ylw(_success)} ${spec.name} ${$ms(ms, $ylw('slow'))}`)
+      } else {
+        context.log.leave(NOTICE, `${$grn(_success)} ${spec.name} ${$ms(ms)}`)
+      }
     })
 
     execution.on('spec:fail', (spec, ms, { number }) => {
@@ -174,6 +182,8 @@ function dumpError(log: Logger, error: any, genericErrorDiffs: boolean): void {
   // First and foremost, our own expectation errors
   if (error instanceof ExpectationError) {
     log.enter(ERROR, `${$gry('Expectation Error:')} ${$red(error.message)}`)
+    githubAnnotation({ type: 'error', title: 'Expectation Error' }, error.message)
+
     try {
       dumpProps(log, 17, error)
       dumpStack(log, error)
@@ -186,7 +196,10 @@ function dumpError(log: Logger, error: any, genericErrorDiffs: boolean): void {
   // Assertion errors are another kind of exception we support
   } else if (error instanceof AssertionError) {
     const [ message = 'Unknown Error', ...lines ] = error.message.split('\n')
+
     log.enter(ERROR, `${$gry('Assertion Error:')} ${$red(message)}`)
+    githubAnnotation({ type: 'error', title: 'Assertion Error' }, message)
+
     try {
       dumpProps(log, 15, error)
       dumpStack(log, error)
@@ -209,10 +222,16 @@ function dumpError(log: Logger, error: any, genericErrorDiffs: boolean): void {
   // Any other error also gets printed somewhat nicely
   } else if (error instanceof Error) {
     const message = error.message || 'Unknown Error'
-    const string = stringifyObjectType(error)
+    const string = Object.getPrototypeOf(error)?.constructor?.name || 'Error'
+
     // Chai calls its own assertion errors "AssertionError"
-    const type = string === '[AssertionError]' ? 'Assertion Error' : string
-    log.enter(ERROR, `${$gry(type)}: ${$red(message)}`)
+    const type =
+        string === 'AssertionError' ? `${$gry('Assertion Error')}: ` :
+        string === 'Error' ? '' : `${$gry(string)}: `
+
+    log.enter(ERROR, `${type}${$red(message)}`)
+    githubAnnotation({ type: 'error', title: string }, message)
+
     try {
       dumpProps(log, type.length, error)
       dumpStack(log, error)
@@ -244,6 +263,8 @@ function dumpProps(log: Logger, pad: number, error: Error): void {
         'showDiff', // chai
         'stack', // error
       ].includes(k))
+      .filter((k) => !(error[k as keyof typeof error] === null))
+      .filter((k) => !(error[k as keyof typeof error] === undefined))
       .forEach((k) => {
         const value = error[k as keyof typeof error]
         if ((k === 'code') && (value === 'ERR_ASSERTION')) return