Re-add tests

Author: ehmicky

src/main.test.js

@@ -4,8 +4,6 @@ import { each } from 'test-each'
 
 import { handleError } from './helpers/main.test.js'
 
-const testError = new TypeError('test')
-
 each(
   [
     { error: undefined, expectedMessage: 'Error: undefined' },
@@ -28,8 +26,3 @@ test.serial('validateOpts() throws on invalid options', (t) => {
 test.serial('validateOpts() does not throw on valid options', (t) => {
   t.notThrows(validateOptions.bind(undefined, { silent: true }))
 })
-
-test.serial('Does not log if "silent" is true', (t) => {
-  const { consoleArg } = handleError(testError, { silent: true })
-  t.is(consoleArg, undefined)
-})

src/print/colors.test.js

@@ -0,0 +1,48 @@
+import test from 'ava'
+import chalkString from 'chalk-string'
+import hasAnsi from 'has-ansi'
+import { each } from 'test-each'
+
+import { handleError } from '../helpers/main.test.js'
+
+const testError = new TypeError('test')
+const addStyles = chalkString({ colors: true })
+
+each([true, false], ({ title }, colors) => {
+  test.serial(`Add colors unless "colors" is false | ${title}`, (t) => {
+    const { consoleArg } = handleError(testError, { colors })
+    t.is(hasAnsi(consoleArg), colors !== false)
+  })
+})
+
+test.serial('"colors" defaults to TTY color support', (t) => {
+  const { consoleArg } = handleError(testError)
+  t.false(hasAnsi(consoleArg))
+})
+
+each(
+  [
+    { quote: '"', styles: 'bold' },
+    { quote: "'", styles: 'bold' },
+    { quote: '`', styles: 'italic' },
+  ],
+  [true, false],
+  ({ title }, { quote, styles }, hasNewline) => {
+    test.serial(`"colors" colorize quoted strings | ${title}`, (t) => {
+      const newline = hasNewline ? '\n' : ''
+      const error = new Error(
+        `a ${quote}b${newline}${quote} c ${quote}d${quote}`,
+      )
+      const { consoleArg } = handleError(error, { colors: true })
+      t.not(
+        consoleArg.includes(
+          `a ${quote}${addStyles(
+            styles,
+            'b',
+          )}${newline}${quote} c ${quote}${addStyles(styles, 'd')}${quote}`,
+        ),
+        hasNewline,
+      )
+    })
+  },
+)

src/print/header.test.js

@@ -0,0 +1,65 @@
+import test from 'ava'
+import chalkString from 'chalk-string'
+import figures from 'figures'
+import { each } from 'test-each'
+
+import { handleError } from '../helpers/main.test.js'
+
+const addStyles = chalkString({ colors: true })
+const testOpts = { icon: '', colors: true }
+
+each(
+  [
+    { header: undefined, styles: 'red bold' },
+    { header: 'bold', styles: 'bold' },
+    { header: 'red bold', styles: 'red bold' },
+  ],
+  ({ title }, { header, styles }) => {
+    test.serial(`"header" is applied | ${title}`, (t) => {
+      const error = new Error('test')
+      const { consoleArg } = handleError(error, { ...testOpts, header })
+      t.true(consoleArg.includes(addStyles(styles, `${error.name}:`)))
+      t.pass()
+    })
+  },
+)
+
+each([{ colors: false }, { header: '' }], ({ title }, opts) => {
+  test.serial(
+    `"header" is not applied if empty or no colors | ${title}`,
+    (t) => {
+      const error = new Error('test')
+      const { consoleArg } = handleError(error, { ...testOpts, ...opts })
+      t.true(consoleArg.includes(`${error.name}: `))
+      t.pass()
+    },
+  )
+})
+
+test.serial('"header" is not added to preview lines', (t) => {
+  const error = new Error('test')
+  const preview = 'preview'
+  error.stack = `${preview}\n${error.stack}`
+  const { consoleArg } = handleError(error, testOpts)
+  t.true(consoleArg.startsWith(preview))
+})
+
+test.serial('"header" works with empty messages', (t) => {
+  const error = new Error('')
+  const header = 'green'
+  const { consoleArg } = handleError(error, { ...testOpts, header })
+  t.true(consoleArg.includes(addStyles(header, error.name)))
+})
+
+test.serial('"header" colorizes the icon', (t) => {
+  const error = new Error('test')
+  const header = 'green'
+  const { consoleArg } = handleError(error, {
+    ...testOpts,
+    icon: 'warning',
+    header,
+  })
+  t.true(
+    consoleArg.includes(addStyles(header, `${figures.warning} ${error.name}:`)),
+  )
+})

src/print/icon.test.js

@@ -0,0 +1,27 @@
+import test from 'ava'
+import figures from 'figures'
+import { each } from 'test-each'
+
+import { handleError } from '../helpers/main.test.js'
+
+each(
+  [
+    { icon: '', output: '' },
+    { icon: undefined, output: `${figures.cross} ` },
+    { icon: 'warning', output: `${figures.warning} ` },
+  ],
+  ({ title }, { icon, output }) => {
+    test.serial(`"icon" prepends an icon | ${title}`, (t) => {
+      const error = new Error('test')
+      const { consoleArg } = handleError(error, { icon })
+      t.true(consoleArg.includes(`${output}${error.name}`))
+    })
+  },
+)
+
+test.serial('"icon" is not added to preview lines', (t) => {
+  const error = new Error('test')
+  error.stack = `preview\n${error.stack}`
+  const { consoleArg } = handleError(error, { icon: 'warning' })
+  t.true(consoleArg.includes(`${figures.warning} ${error.name}`))
+})

src/print/main.test.js

@@ -0,0 +1,10 @@
+import test from 'ava'
+
+import { handleError } from '../helpers/main.test.js'
+
+const testError = new TypeError('test')
+
+test.serial('Does not log if "silent" is true', (t) => {
+  const { consoleArg } = handleError(testError, { silent: true })
+  t.is(consoleArg, undefined)
+})

src/print/pretty.test.js

@@ -0,0 +1,39 @@
+import test from 'ava'
+import chalkString from 'chalk-string'
+import { each } from 'test-each'
+
+import { handleError } from '../helpers/main.test.js'
+
+const addStyles = chalkString({ colors: true })
+
+test.serial('"colors" does not colorize quoted strings in stack line', (t) => {
+  const error = new Error('test')
+  const stackLines = '    at "a"'
+  error.stack = `Error: test\n${stackLines}`
+  const { consoleArg } = handleError(error, { colors: true })
+  t.true(consoleArg.endsWith(stackLines))
+})
+
+each(['Error: ', 'Error [TypeError]: '], ({ title }, name) => {
+  test.serial(
+    `"colors" does not colorize quoted strings in preview lines | ${title}`,
+    (t) => {
+      const error = new Error('test "b"')
+      const previewLines = '"a"'
+      error.stack = `${previewLines}\n${name}${error.stack}`
+      const { consoleArg } = handleError(error, { colors: true })
+      t.true(consoleArg.startsWith(previewLines))
+      t.true(consoleArg.includes(`"${addStyles('bold', 'b')}"`))
+    },
+  )
+})
+
+test.serial(
+  '"colors" does not colorize quoted strings without preview nor lines',
+  (t) => {
+    const error = new Error('test')
+    error.stack = '"a"'
+    const { consoleArg } = handleError(error, { colors: true })
+    t.true(consoleArg.includes(`"${addStyles('bold', 'a')}"`))
+  },
+)

src/print/props.test.js

@@ -0,0 +1,19 @@
+import test from 'ava'
+import { each } from 'test-each'
+
+import { handleError } from '../helpers/main.test.js'
+
+const propsError = new TypeError('test')
+// eslint-disable-next-line fp/no-mutation
+propsError.prop = 'propValue'
+
+each(
+  [true, false, undefined],
+  [true, false, undefined],
+  ({ title }, stack, props) => {
+    test.serial(`Prints properties unless "props" is false | ${title}`, (t) => {
+      const { consoleArg } = handleError(propsError, { stack, props })
+      t.is(consoleArg.includes(propsError.prop), props !== false)
+    })
+  },
+)

src/print/stack.test.js

@@ -0,0 +1,87 @@
+import test from 'ava'
+import { serialize } from 'error-serializer'
+import { each } from 'test-each'
+
+import { handleError } from '../helpers/main.test.js'
+
+const createDeepErrors = () => Array.from({ length: 5 }, createDeepError)
+
+const createDeepError = (_, depth) => {
+  const error = new TypeError('test')
+  setDeepError(error, depth)
+  return error
+}
+
+const setDeepError = (error, depth) => {
+  if (depth === 0) {
+    return
+  }
+
+  // eslint-disable-next-line fp/no-mutating-methods
+  Object.defineProperty(error, 'cause', {
+    value: new TypeError('test'),
+    enumerable: false,
+    writable: true,
+    configurable: true,
+  })
+  // eslint-disable-next-line fp/no-delete
+  delete error.stack
+  setDeepError(error.cause, depth - 1)
+}
+
+const recursiveError = new TypeError('test')
+// eslint-disable-next-line fp/no-mutation
+recursiveError.self = recursiveError
+const deepErrors = createDeepErrors()
+const ownNameError = new Error('test')
+// eslint-disable-next-line fp/no-mutation
+ownNameError.name = 'TypeError'
+const noStackError = new Error('test')
+// eslint-disable-next-line fp/no-mutating-methods
+Object.defineProperty(noStackError, 'stack', { value: noStackError.toString() })
+
+each(
+  [recursiveError, noStackError, ...deepErrors],
+  [true, false, undefined],
+  [true, false, undefined],
+  // eslint-disable-next-line max-params
+  ({ title }, error, stack, props) => {
+    test.serial(`Prints stack unless "stack" is false | ${title}`, (t) => {
+      const { consoleArg } = handleError(error, { stack, props })
+      t.is(
+        consoleArg.includes('at '),
+        stack !== false && error.stack.includes('at '),
+      )
+    })
+
+    test.serial(`Does not put the error in brackets | ${title}`, (t) => {
+      const { consoleArg } = handleError(error, { stack, props, icon: '' })
+      t.false(consoleArg.startsWith('['))
+    })
+
+    test.serial(`Does not modify the error | ${title}`, (t) => {
+      const errorCopy = serialize(error)
+      handleError(error, { stack, props })
+      t.deepEqual(serialize(error), errorCopy)
+    })
+
+    test.serial(`Prints error name and message | ${title}`, (t) => {
+      const { consoleArg } = handleError(error, { stack, props })
+      t.true(consoleArg.includes(`${error.name}: ${error.message}`))
+    })
+  },
+)
+
+each([true, false], ({ title }, stack, props) => {
+  test.serial(`Prints error name consistently | ${title}`, (t) => {
+    const { consoleArg } = handleError(ownNameError, { stack: false, props })
+    t.true(consoleArg.includes(`Error [${ownNameError.name}`))
+  })
+})
+
+test.serial('Does not remove stacks from non-errors', (t) => {
+  const error = new Error('test')
+  error.prop = { stack: 'propStack' }
+  const { consoleArg } = handleError(error, { stack: false, props: true })
+  t.true(consoleArg.includes(error.prop.stack))
+})