@sap/cds 8.9.4 → 9.0.2

package/lib/test/expect.js

@@ -1,343 +0,0 @@
-const { inspect } = require('node:util')
-const format = x => inspect(
-  is.error(x) ? x.message
-  : typeof x === 'object' && 'status' in x && 'body' in x ? { status: x.status, body: x.body }
-  : typeof x === 'object' && 'status' in x && 'data' in x ? { status: x.status, data: x.data }
-  : x,
-  { colors: true, sorted: true, depth: 11 }
-)
-
-const expect = module.exports = actual => {
-  const chainable = function (x) { return this.call(x) }; delete chainable.length
-  return Object.setPrototypeOf(chainable, new Assertion(actual))
-}
-
-const is = new class {
-  Array = Array.isArray
-  Error = x => x instanceof Error || x?.stack && x.message
-  Symbol = x => typeof x === 'symbol'
-  Object = x => typeof x === 'object' // && x && !is.array(x)
-  String = x => typeof x === 'string' || x instanceof String
-  Number = x => typeof x === 'number' || x instanceof Number
-  Boolean = x => typeof x === 'boolean' || x instanceof Boolean
-  Promise = x => x instanceof Promise
-  RegExp = x => x instanceof RegExp
-  Date = x => x instanceof Date
-  Set = x => x instanceof Set
-  Map = x => x instanceof Map
-  array = this.Array
-  error = this.Error
-  symbol = this.Symbol
-  object = this.Object
-  string = this.String
-  number = this.Number
-  boolean = this.Boolean
-  promise = this.Promise
-  regexp = this.RegExp
-  date = this.Date
-  set = this.Set
-  map = this.Map
-  /** Jest-style any matcher */
-  any = expect.any = type => {
-    if (type === undefined) return () => true
-    else return this [type.name || type] || (x => x instanceof type)
-  }
-}
-
-
-class Core {
-
-  constructor (actual) { this._ = actual }
-
-  /** The central method to throw an AssertionError. */
-  expected ([a, be, ...etc], ...args) {
-    const raw = [a, (this._not ? ' NOT' : '') + be, ...etc]
-    const err = new expected({ raw }, ...args)
-    // err.operator = be.trim().replace(/^to /,'')
-    // err.expected = args[1]
-    // err.actual = args[0]
-    throw err
-  }
-
-  should ([be, ...etc], ...args) {
-    return this.expected(['', ' to ' + be, ...etc], this._, ...args)
-  }
-
-  /** The central method to check assertions. */
-  assert (check, _fail = () => false) {
-    const outcome = check(this._)
-    if (this._not ? outcome : !outcome) return _fail(outcome)
-    else return this
-  }
-
-  instanceof (x) {
-    return this.assert(a => a instanceof x) || this.should`be an instance of ${x.name || x}`
-  }
-
-  kindof (x) {
-    return this.assert(is.any(x)) || this.should`be kind of ${x?.name || x}`
-  }
-
-  equals (x, _fail = () => this.should`strictly equal ${x}`) {
-    if (typeof x === 'function') return this.assert(x)
-    if (this._deep) return this.eqls(x)
-    return this.assert(a => a === x, _fail)
-  }
-
-  eqls (x, _fail = () => this.should`deeply equal ${x}`) {
-    if (typeof x === 'function') return this.assert(x)
-    return this.assert(a => compare(a, x, true), _fail)
-  }
-
-  subset (x, _fail = () => this.should`contain subset ${x}`) {
-    return this.assert(a => {
-      if (is.array(a) && is.array(x)) return x.every(x => a.some(o => compare(o, x, false)))
-      if (is.array(a) && !is.array(x)) return a.some(o => compare(o, x, false))
-      else return compare(a, x, false)
-    }, _fail)
-  }
-
-  matches (x, _fail = () => this.should`match ${x}`) {
-    return this.assert(a => {
-      if (is.regexp(x)) return x.test(a)
-      if (is.string(x)) return a.includes?.(x)
-      if (is.object(x)) return this.subset(x) && !this._not //> to avoid doubled not
-      // if (is.array(x)) return x.every(x => a.includes(x))
-    }, _fail)
-  }
-
-  includes (x, _fail = () => this.should`include ${x}`) {
-    return this.assert(a => {
-      if (!a) expected`an array or string or set or object but got ${a}`
-      if (is.string(a)) return a.includes(x)
-      if (is.array(a)) return a.includes(x) || this._deep && a.some(o => compare(o, x, true))
-      if (is.set(a)) return a.has(x)
-      if (is.object(a)) return compare(a, x, this._deep)
-    }, _fail)
-  }
-
-  oneOf (x, _fail = () => this.should`be one of ${x}`) {
-    return this.assert(a => x.includes(a), _fail)
-  }
-
-  throws (x, _fail = () => this.should`throw ${x}`) {
-    if (is.promise(this._)) return this.rejectsWith(x)
-    return this.assert(a => {
-      if (typeof a === 'function') try { a(); return false } catch (err) { if (!x) return true; else a = err }
-      if (typeof x.test === 'function') return x.test(a)
-      if (typeof x === 'function') return x(a)
-      if (typeof x === 'string') return a == x || a.code == x || a.message?.includes(x)
-      if (typeof x === 'object') return compare(a, x, false)
-    }, _fail)
-  }
-
-  rejectsWith (x) {
-    if (this._not) return Promise.resolve(this._).catch(
-      e => expected`promise to be fulfilled but it was rejected with ${e}`
-    )
-    else return Promise.resolve(this._).then(
-      y => expected`promise to be rejected but it was fulfilled with ${y}`,
-      e => {
-        if (x) expect(e).throws(x, () => expected`promise to be rejected with ${x} but got ${e}`)
-        return e
-      }
-    )
-  }
-
-  length (ln) {
-    return this.assert(a => (a.length ?? String(a).length) === ln, () => this.should`have length ${ln}`)
-  }
-
-  property (p, v) {
-    const has = !this._own ? (a, p) => p in a : Reflect.getOwnPropertyDescriptor
-    const get = (a, p) => has(a, p) ? a[p] : $not_found, $not_found = {}
-    const y = this.assert(() => true) && !this._nested ? get(this._, p) : p.split('.').reduce((a, p) => get(a, p), this._)
-    if (y === $not_found) return this._not || (this._nested
-      ? this.should`have nested property ${p}`
-      : this.should`have property ${p}`)
-    const that = Object.assign(expect(), this, { _: y })
-    if (v !== undefined) return that.eqls(v, () => this._nested
-      ? this.should`have nested property ${p} with value ${v}`
-      : this.should`have property ${p} with value ${v}`)
-    return that
-  }
-
-  keys (...keys) {
-    if (is.array(keys[0])) keys = keys[0]
-    return this.assert(a => keys.every(k => k in a)) || this.should`have all keys ${keys}`
-  }
-
-  gt (x) { return this.assert(a => a > x) || this.should`be > ${x}` }
-  lt (x) { return this.assert(a => a < x) || this.should`be < ${x}` }
-  gte (x) { return this.assert(a => a >= x) || this.should`be >= ${x}` }
-  lte (x) { return this.assert(a => a <= x) || this.should`be <= ${x}` }
-  within (x, y) { return this.assert(a => x <= a && a <= y) || this.should`be within ${[x, y]}` }
-}
-
-
-class Chai extends Core {
-
-  // linguistic chaining
-
-  get to () { return this }
-  get be () { this.call = this.equals; return this }
-  get is () { this.call = this.equals; return this }
-  get at () { return this }
-  get of () { return this }
-  get and () { return this }
-  get but () { return this }
-  get has () { this.call = this.property; return this }
-  get have () { this.call = this.property; return this }
-  get that () { return this }
-  get does () { return this }
-  get with () { return this }
-  get also () { return this }
-  get still () { return this }
-  get which () { return this }
-  get eventually () {
-    this.assert = (fn, _fail) => Promise.resolve(this._).then(a => expect(a).assert(fn, _fail))
-    return this
-  }
-
-  // flags changing behaviour of subsequent methods in the chain
-
-  get not () { this._not = true; return this }
-  get own () { this._own = true; return this }
-  get deep () { this._deep = true; return this }
-  get nested () { this._nested = true; return this }
-  get ordered () { return unsupported() }
-  get any () { return unsupported() }
-  get all () { return this }
-
-  get undefined () { return this.assert(a => a === undefined) || this.should`be undefined` }
-  get exist () { return this.assert(a => a != undefined) || this.should`exist` }
-  get truthy () { return this.assert(a => !!a) || this.should`be truthy` }
-  get falsy () { return this.assert(a => !a) || this.should`be falsy` }
-  get null () { return this.assert(a => a === null) || this.should`be ${null}` }
-  get true () { return this.assert(a => a === true) || this.should`be ${true}` }
-  get false () { return this.assert(a => a === false) || this.should`be ${false}` }
-  get empty () { return this.assert(a => !a?.length === 0 || Object.keys(a).length === 0) || this.should`be empty` }
-  get NaN () { return this.assert(a => isNaN(a)) || this.should`be ${NaN}` }
-  get ok () { return this.truthy }
-
-  get containSubset () { return this.subset }
-  get contains () { return this.includes }
-  get contain () { return this.includes }
-  get include () { return this.includes }
-  get match () { return this.matches }
-  get equal () { return this.equals }
-  get eq () { return this.equals }
-  get eql () { return this.eqls }
-  get exists () { return this.defined }
-  get lengthOf () { return this.length }
-  get instanceOf () { return this.instanceof }
-  get kindOf () { return this.kindof }
-  get kind () { return this.kindof }
-  get an () { this.call = this.kindof; return this }
-  get a () { this.call = this.kindof; return this }
-  get key () { return this.keys }
-
-  get below () { return this.lt }
-  get above () { return this.gt }
-  get most () { return this.lte }
-  get least () { return this.gte }
-  get lessThan () { return this.lt }
-  get greaterThan () { return this.gt }
-  get lessThanOrEqual () { return this.lte }
-  get greaterThanOrEqual () { return this.gte }
-
-  get throw () { return this.throws }
-  get fulfilled () { return this.not.rejectsWith() }
-  get rejected () { return this.rejectsWith() }
-  get rejectedWith () { return this.rejectsWith }
-}
-
-
-class Jest extends Chai {
-
-  get rejects () { return this }
-  get toBe () { return this.equals }
-  get toEqual () { return this.eqls }
-  get toMatch () { return this.matches }
-  get toMatchObject () { return this.matches }
-  get toContain () { return this.includes }
-  get toThrow () { return this.throws }
-  get toThrowError () { return this.throws }
-  get toBeGreaterThan () { return this.gt }
-  get toBeLessThan () { return this.lt }
-  get toBeGreaterThanOrEqual () { return this.gte }
-  get toBeLessThanOrEqual () { return this.lte }
-  get toHaveProperty () { return this.nested.property }
-  get toHaveLength () { return this.length }
-
-  toBeFalsy () { return this.falsy }
-  toBeTruthy () { return this.truthy }
-  toBeDefined () { return this.defined }
-  toBeUndefined () { return this.undefined }
-  toBeInstanceOf () { return this.instanceof }
-  toMatchSnapshot () { unsupported('toMatchSnapshot') }
-
-  static expect() {
-    expect.stringMatching = x => a => (is.regexp(x) ? x : RegExp(x)).test?.(a)
-    expect.arrayContaining = x => a => x.every(e => a.includes(e))
-    expect.any = is.any
-  }
-}
-Jest.expect()
-
-
-class Assertion extends Jest {
-  toString() { return `[ expect: ${format(this._)} ]` }
-}
-
-
-class AssertionError extends Error {
-  constructor (m, caller = Assertion.prototype.should) { Error.captureStackTrace (super(m), caller) }
-  get caller() { return Assertion.prototype.should }
-  get code() { return 'ERR_ASSERTION' }
-}
-
-// function AssertionError(m){
-//   Error.captureStackTrace (this,this.caller)
-//   this.message = m
-// }
-// AssertionError.prototype = Object.create (Error.prototype, {constructor:{value: AssertionError }})
-// AssertionError.__proto__ = Error
-
-
-expect.fail = function (actual, expected, message) {
-  if (arguments.length === 1) throw new AssertionError (actual, expect.fail)
-  if (arguments.length === 3) throw Object.assign (new AssertionError (message, expect.fail), { expected, actual })
-}
-
-function expected (strings, ...args) {
-  const err = new AssertionError ('expected ' + String.raw(strings, ...args.map(format)))
-  if (new.target) return err; else throw err
-}
-
-function unsupported (method) {
-  const ignore = unsupported.skip ??= (process.env._chest_skip || '')?.split(',').reduce((p, c) => (p[c] = 1, p), {})
-  if (!method) return new Error(`unsupported`)
-  if (method in ignore) return () => { }
-  else throw new Error(`
-    Method expect .${method}() is not yet supported.
-    Use --skip ${method} to skip checks.
-  `)
-}
-
-function compare (a, b, strict) {
-  if (a == b) return true
-  return function _recurse (a, b) {
-    if (!a || typeof a !== 'object') return false
-    if (!b || typeof b !== 'object') return false
-    if (strict)
-      for (let k of Object.keys(a)) if (!(k in b))
-        return false
-    for (let k in b) {
-      const v = a[k], x = b[k]; if (v === x) continue
-      if (typeof x === 'function') { if (x(v)) continue; else return false }
-      if (!_recurse(v, x)) return false
-    }
-    return true
-  }(a, b)
-}

package/lib/test/reporter.js

@@ -1,176 +0,0 @@
-const { BRIGHT, BOLD, INVERT, GRAY, GREEN, RESET, LF='\n', DIMMED } = require('../utils/colors')
-const YELLOW = '\x1b[38;5;220m'
-const RED = '\x1b[38;5;160m'
-const PASS = '\x1b[38;5;244m'
-const FAIL = '\x1b[38;5;244m' // '\x1b[38;5;124m'
-const SKIP = RESET+DIMMED // '\x1b[38;5;244m' // '\x1b[38;5;124m'
-const { inspect } = require('node:util')
-/* eslint-disable no-console */
-
-module.exports = function report_on (test,o) {
-
-  const files = o.files
-  const suites = { passed:[], failed:[] }
-  const tests = { passed:0, failed:0, todo:0, skipped:0, recent:null }
-
-  // monkey-patch test.on to support filter functions like root, leaf, any
-  const {on} = test; test.on = (eve,filter,fn) => on.call (test, 'test:'+eve, !fn ? fn = filter : x => filter(x) && fn(x))
-  const root = x => !x.nesting && x.name.endsWith('.js')
-  const leaf = x => x.name[0] !== '<' && x.details?.type !== 'suite'
-  const any = x => x.name[0] !== '<'
-  const _indent4 = x => '  '.repeat (x.nesting + root(x))
-
-  // add handlers according to options
-  if (o.debug ??= process.env.debug) return debug(o.debug) // eslint-disable-line no-cond-assign
-  if (o.verbose || !o.silent && files.length < 2) verbose(); else silent()
-  if (o.unmute) unmute()
-  common()
-  return test
-
-
-  /**
-   * Adds common handlers to report test results.
-   * Used in silent mode as well as verbose mode.
-   */
-  function common() {
-
-    test.on ('pass', leaf, x => {
-      x.skip ? tests.skipped++ : x.todo ? tests.todo++ : tests.passed++
-    })
-
-    test.on ('fail', x => {
-      if (x.details.error.failureType in { subtestsFailed:1, cancelledByParent: 2 }) return
-      tests.failed++
-      if (o.silent) console.log(_indent4(x), BOLD + RED, 'X' + RESET+GRAY, x.name, RESET)
-      if (o.quiet) return
-      let err = x.details.error.cause || x.details.error
-      let msg = typeof err === 'string' ? err : inspect (err, { colors:true, depth:11 })
-      console.log(RESET)
-      console.log(msg
-        .replace(/\n.*cds\/lib\/test\/expect.js:.*\)/g,'')
-        .replace(/\n.*\(node:.*/g,'')
-        .replace(/^/gm, _indent4(x)+'  ')
-      )
-      if (!err.message && !o.unmute)
-        console.log('   ', INVERT+YELLOW, 'NOTE', RESET+YELLOW, '--unmute app log output to see error details.', RESET )
-      console.log(RESET)
-    })
-
-    test.on ('complete', root, x => {
-      (x.details.passed ? suites.passed : suites.failed) .push (x.file)
-    })
-
-    test.once ('fail', ()=> process.exitCode = 1)
-    process.on('exit', summary)
-  }
-
-
-  /**
-   * Adds handlers to report test results on root-level only,
-   * i.e., on test file level.
-   */
-  function silent() {
-    console.log() // start with an initial blank line
-    test.on ('complete', root, x => {
-      if (x.details.passed) console.log (GREEN,' ✔', RESET+PASS, x.name)
-      else console.log (BRIGHT+RED,' X', RESET+RED, x.name, RESET)
-    })
-  }
-
-
-  /**
-   * Adds handlers to report test results in detail,
-   * i.e., on nested tests level.
-   */
-  function verbose() {
-
-    // report tests on file level
-    let i=0
-    if (files.length > 1 || files[0] !== process.argv[2] && files[0] !== process.argv[3]) // if not only one completely specified test file
-      test.on ('dequeue', x => x.name === '<next>' && console.log (LF+GRAY+'—'.repeat(77)+BRIGHT, LF+ files[i++], RESET))
-
-    // report test suites (i.e, describe/suite/test with subtests)
-    let _recent = null, _recent_nesting = 0 // to add newlines before outer leaf tests following a suite
-    test.on ('start', any, x => {
-      if (_recent) {
-        console.log(LF+_indent4(_recent), '', _recent.name)
-        _recent_nesting = x.nesting
-      }
-      _recent = x
-    })
-
-    // report passed tests on leaf level
-    test.on ('pass', leaf, x => {
-      if (_recent_nesting > x.nesting && leaf(x)) console.log()
-      x.skip ? console.log(_indent4(x), YELLOW, '○' + SKIP, x.name, RESET) :
-      x.todo ? console.log(_indent4(x), YELLOW, '+' + SKIP, x.name, RESET) :
-      /*pass*/ console.log(_indent4(x), GREEN,  '✔' + PASS, x.name, RESET)
-      _recent_nesting = _recent?.nesting
-      _recent = null
-    })
-
-    // report failed tests on leaf level
-    test.on ('fail', leaf, x => {
-      if (_recent_nesting > x.nesting && leaf(x)) console.log()
-      console.log(_indent4(x), BOLD+RED, 'X' + RESET+FAIL, x.name, RESET)
-      _recent_nesting = _recent?.nesting
-      _recent = null
-    })
-  }
-
-
-  /**
-   * Adds handlers to pipe stdout and stderr of the tests themselves
-   * or the app servers started in there.
-   */
-  function unmute() {
-    test.on ('stdout', x => process.stdout.write(x.message))
-    test.on ('stderr', x => process.stderr.write(x.message))
-  }
-
-
-  /**
-   * Adds handlers to debug test stream events.
-   */
-  function debug (events) {
-    inspect.defaultOptions.depth = 11
-    if (events === 'all') events = 'enqueue,dequeue,start,pass,fail,complete,error'
-    for (let eve of events.split(',')) test.on (eve, x => {
-      if (x.details) x.details = { ...x.details }
-      // delete x.testNumber
-      // delete x.details
-      // delete x.file
-      // delete x.line
-      // delete x.column
-      console.log(INVERT + YELLOW, eve, RESET, { ...x })
-    })
-  }
-
-
-  /**
-   * Prints the summary of passed, skipped, failed tests.
-   */
-  function summary () {
-    const time = (performance.now() / 1000).toFixed(3)
-    console.log(
-      report ('passed', BOLD+GREEN) +
-      report ('failed', BOLD+RED) +
-      report ('skipped', YELLOW) +
-      report ('todo', YELLOW) +
-      `\n${PASS} ${time}s ${RESET}\n`
-    )
-    function report (kind, color) {
-      const t = tests[kind], s = suites[kind]?.length || 0
-      if (t == 0) return ''
-      if (s == 0 || files.length == 1) return LF+`${color} ${t} ${kind} ${RESET}`
-      else return LF+`${color} ${t} in ${s} suite${s==1?'':'s'} ${kind} ${RESET}`
-    }
-    const _recent = require('os').userInfo().homedir + '/.cds-test-recent.json'
-    const recent = require('fs').existsSync(_recent) ? require(_recent) : {}
-    if (!o.recent && !o.passed && !o.failed) recent.options = {...o, argv:process.argv.slice(2) }
-    if (!o.failed) recent.passed = suites.passed // only update recent.passed if not called w/ --failed
-    if (!o.passed) recent.failed = suites.failed // only update recent.failed if not called w/ --passed
-    require('fs').writeFileSync(_recent, JSON.stringify(recent,null,2))
-  }
-
-}