@camperaid/watest 2.4.7 → 2.4.8

package/.prettierrc.js

@@ -1,6 +1,4 @@
-'use strict';
-
-module.exports = {
+export default {
   printWidth: 80,
   singleQuote: true,
   quoteProps: 'consistent',

package/.watestrc.js

@@ -1,5 +1,3 @@
-'use strict';
-
 const cfg = {
   /**
    * Test run and invocation. If not set, then the testuiste will generate them.
@@ -61,4 +59,4 @@ const cfg = {
   ignore_pattern: process.env.WATEST_IGNORE_PATTERN,
 };
 
-module.exports = cfg;
+export default cfg;

package/bin/watest.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
-'use strict';
-
-const { ProcessArgs } = require('../core/process_args.js');
+import { ProcessArgs } from '../core/process_args.js';
+import '../core/settings.js';
+import { runSeries } from '../core/series.js';
 
 const args = ProcessArgs.asObject();
 if (args.showHelp) {
@@ -19,9 +19,4 @@ Options:
   process.exit();
 }
 
-// Initalize config.
-require('../core/settings.js');
-
-// Run tests.
-const { runSeries } = require('../core/series.js');
 runSeries(args.patterns, args).then(failures => failures && process.exit(1));

package/core/base.js

@@ -1,11 +1,7 @@
-'use strict';
-
-const core = require('./core.js');
-const { success, fail, failed } = core;
-
-const { log, log_error } = require('../logging/logging.js');
-const { format_failure } = require('./format.js');
-const { stringify } = require('./util.js');
+import { success, fail, failed } from './core.js';
+import { format_failure, stderr_unwrap } from './format.js';
+import { stringify } from './util.js';
+import { log, log_error } from '../logging/logging.js';
 
 const limit = 100;
 
@@ -36,7 +32,7 @@ function test_is(got, expected, options = {}) {
     Object.assign(options, {
       fail_: dummy,
       success_: dummy,
-    })
+    }),
   );
 }
 
@@ -51,7 +47,7 @@ function test_contains(got, expected, options = {}) {
     Object.assign(options, {
       fail_: dummy,
       success_: dummy,
-    })
+    }),
   );
 }
 
@@ -69,7 +65,7 @@ function contains(
   got,
   expected,
   msg,
-  { ignore_unexpected, fail_ = fail, success_ = success } = {}
+  { ignore_unexpected, fail_ = fail, success_ = success } = {},
 ) {
   if (typeof got == 'string' || typeof expected == 'string') {
     if (typeof got != 'string') {
@@ -79,8 +75,8 @@ function contains(
     if (typeof expected != 'string') {
       fail_(
         `${msg}, got string, expected ${typeof expected}: ${stringify(
-          expected
-        )}`
+          expected,
+        )}`,
       );
       return false;
     }
@@ -90,15 +86,15 @@ function contains(
     }
     fail_(
       `${msg}, got string doesn't contain expected string, got: ${stringify(
-        got
-      )}, expected: ${stringify(expected)}`
+        got,
+      )}, expected: ${stringify(expected)}`,
     );
     return false;
   }
 
   if (!(expected instanceof Array)) {
     fail_(
-      `${msg}, expected value is not array, expected: ${stringify(expected)}`
+      `${msg}, expected value is not array, expected: ${stringify(expected)}`,
     );
     return false;
   }
@@ -110,7 +106,7 @@ function contains(
 
   if (got.length < expected.length) {
     fail_(
-      `${msg}, array is lesser than expected, ${got.length} vs ${expected.length}`
+      `${msg}, array is lesser than expected, ${got.length} vs ${expected.length}`,
     );
     return false;
   }
@@ -120,13 +116,13 @@ function contains(
       !got.find(g =>
         test_is(g, e, {
           ignore_unexpected,
-        })
+        }),
       )
     ) {
       fail_(
         `${msg}, array has no expected item ${stringify(e)}, got: ${stringify(
-          got
-        )}`
+          got,
+        )}`,
       );
       return false;
     }
@@ -140,14 +136,14 @@ function is_string(
   got,
   expected,
   msg,
-  { fail_ = fail, success_ = success } = {}
+  { fail_ = fail, success_ = success } = {},
 ) {
   // Different types.
   if (typeof got != 'string' || typeof expected != 'string') {
     fail_(
       `${msg} type mismatch, ` +
         `got type: ${typeof got}, expected type: ${typeof expected}, ` +
-        `got value: ${stringify(got)}, expected value: ${stringify(expected)}`
+        `got value: ${stringify(got)}, expected value: ${stringify(expected)}`,
     );
     return false;
   }
@@ -161,7 +157,7 @@ function is_string(
       fail_(
         `${msg};\ngot:\n${got}\nexpected:\n${expected}\n` +
           `unexpected character: '${got.charAt(i)}' at ${i} pos, ` +
-          `expected: '${expected.charAt(i)}' at '${line}' line`
+          `expected: '${expected.charAt(i)}' at '${line}' line`,
       );
       return false;
     }
@@ -178,7 +174,7 @@ function is_string(
   let expected_str = `expected: '${expected}' of ${expected.length} chars`;
   let diff_str = `diff: '${expected.substring(got.length)}'`;
   fail_(
-    `${msg}, string longer than expected, ${got_str}, ${expected_str}, ${diff_str}`
+    `${msg}, string longer than expected, ${got_str}, ${expected_str}, ${diff_str}`,
   );
   return false;
 }
@@ -187,7 +183,7 @@ function is_primitive(
   got,
   expected,
   msg,
-  { enrich_failure_msg, fail_ = fail, success_ = success } = {}
+  { enrich_failure_msg, fail_ = fail, success_ = success } = {},
 ) {
   const enrichmsg = (enrich_failure_msg && `${msg} value mismatch`) || msg;
 
@@ -206,7 +202,7 @@ function is_primitive(
       return true;
     }
     fail_(
-      `${enrichmsg}, got: ${printable_got}, expected: ${expected.toString()}`
+      `${enrichmsg}, got: ${printable_got}, expected: ${expected.toString()}`,
     );
     return false;
   }
@@ -232,7 +228,7 @@ function is_primitive(
     fail_(
       `${msg} type mismatch, ` +
         `got type: ${typeof got}, expected type: ${typeof expected}, ` +
-        `got value: ${stringify(got)}, expected value: ${stringify(expected)}`
+        `got value: ${stringify(got)}, expected value: ${stringify(expected)}`,
     );
     return false;
   }
@@ -256,7 +252,7 @@ function is_object(
     do_not_print_got_on_success,
     fail_ = fail,
     success_ = success,
-  } = {}
+  } = {},
 ) {
   // Primitive values.
   if (!(got instanceof Object)) {
@@ -281,13 +277,12 @@ function is_object(
   return false;
 }
 
-// eslint-disable-next-line complexity
 function is_object_impl(
   got,
   expected,
   msg,
   fieldpath,
-  { ignore_unexpected, fail_, success_ }
+  { ignore_unexpected, fail_, success_ },
 ) {
   const contextmsg = `${msg}${(fieldpath && ` '${fieldpath}' field`) || ''}`;
 
@@ -324,7 +319,7 @@ function is_object_impl(
   ) {
     fail_(
       `${contextmsg} class mismatch, got: ${got.constructor.name}, ` +
-        `expected: ${(expected && expected.constructor.name) || expected}`
+        `expected: ${(expected && expected.constructor.name) || expected}`,
     );
     return false;
   }
@@ -355,7 +350,7 @@ function is_object_impl(
           expected.length
         }.
 Got: ${stringify(got)}
-Expected: ${stringify(expected)}`
+Expected: ${stringify(expected)}`,
       );
       return false;
     }
@@ -369,8 +364,8 @@ Expected: ${stringify(expected)}`
         let fpath = (fieldpath && `${fieldpath}->${field}`) || field;
         fail_(
           `${msg} '${fpath}' field was not expected, got: ${stringify(
-            got[field]
-          )}`
+            got[field],
+          )}`,
         );
         isok = false;
       }
@@ -422,7 +417,7 @@ async function is_test_output(func, out, err, msg) {
     func,
     out.map(expected => got => got.trim().startsWith(expected)),
     err.map(expected => got => got.trim().startsWith(expected)),
-    msg
+    msg,
   );
 
   if (!stdout_matched || !stderr_matched) {
@@ -465,6 +460,9 @@ async function capture_output(func) {
     fail(expection);
   }
 
+  // Adjust stderr.
+  stderr = stderr.map(stderr_unwrap);
+
   return {
     stdout,
     stderr,
@@ -528,8 +526,8 @@ function is_out(got, expected, msg) {
         log_error(
           format_failure(
             `got: ${stringify(got_i)}, expected: ${exp_i}`,
-            `Unexpected output at index ${i},`
-          )
+            `Unexpected output at index ${i},`,
+          ),
         );
       }
       continue;
@@ -544,25 +542,11 @@ function is_out(got, expected, msg) {
         `got: ${stringify(got_i)}, expected: ${exp_i}, got len: ${
           got_i.length
         }, expected len: ${exp_i.length}`,
-        `Unexpected output at index ${i},`
-      )
-    );
-    log_error(
-      `index\tgot\texpected\tequal ${Math.min(got_i.length, exp_i.length)}`
+        `Unexpected output at index ${i},`,
+      ),
     );
 
-    let min = Math.min(got_i.length, exp_i.length);
-    for (let j = 0; j < min; j++) {
-      log_error(`${j}\t'${got_i[j]}'\t'${exp_i[j]}'\t${exp_i[j] == got_i[j]}`);
-    }
-
-    for (let j = min; j < got_i.length; j++) {
-      log_error(`${j}\t'${got_i[j]}'`);
-    }
-
-    for (let j = min; j < exp_i.length; j++) {
-      log_error(`${j}\t\t'${exp_i[j]}'`);
-    }
+    print_string_diff(got_i, exp_i);
   }
   return false;
 }
@@ -586,11 +570,31 @@ function no_throws(func, msg) {
   }
 }
 
-module.exports = {
+function print_string_diff(got, expected) {
+  log_error(`index\tgot\texpected\tgot\texpected`);
+
+  let min = Math.min(got.length, expected.length);
+  for (let j = 0; j < min; j++) {
+    log_error(
+      `${j}\t'${got[j]}'\t'${expected[j]}'\t${
+        expected[j] == got[j] ? '' : 'false'
+      }\t${got[j].charCodeAt(0)}\t${expected[j].charCodeAt(0)}`,
+    );
+  }
+
+  for (let j = min; j < got.length; j++) {
+    log_error(`${j}\t'${got[j]}'`);
+  }
+
+  for (let j = min; j < expected.length; j++) {
+    log_error(`${j}\t\t'${expected[j]}'`);
+  }
+}
+
+export {
   success,
   fail,
   failed,
-
   ok,
   is,
   contains,
@@ -599,13 +603,10 @@ module.exports = {
   is_object,
   is_primitive,
   is_string,
-
   throws,
   no_throws,
-
   test_is,
   test_contains,
-
   capture_output,
   capture_test_output,
   format_test_output,

package/core/core.js

@@ -1,27 +1,25 @@
-'use strict';
-
-const { log, log_error, log_trace } = require('../logging/logging.js');
-const {
+import { log, log_error, log_trace } from '../logging/logging.js';
+import {
   format_failure,
   format_intermittent,
   format_ok,
   format_warning,
   colorify,
-} = require('./format.js');
-const { inspect, initTmpStorage } = require('./util.js');
+} from './format.js';
+import { inspect, initTmpStorage } from './util.js';
 
 /**
  * Tracks testing flow, all the failures, intermittents, successes etc.
  */
 class Core {
-  constructor() {
+  constructor(timeout) {
     this.kcnt = 0;
     this.fcnt = 0;
     this.todocnt = 0;
     this.intermittentcnt = 0;
     this.warningcnt = 0;
 
-    this.timeout = 0;
+    this.timeout = timeout ?? 0;
 
     // Current group.
     this.currgroup = null;
@@ -142,7 +140,7 @@ class Core {
 
   failIfExpectedFailurePass() {
     let has_expected_failure = this.expectedFailures.some(f =>
-      f.list.every(li => li[1] > 0)
+      f.list.every(li => li[1] > 0),
     );
     if (!has_expected_failure) {
       for (let f of this.expectedFailures) {
@@ -150,7 +148,7 @@ class Core {
           let mf = f.list.find(f => f[1] == 0);
           if (mf) {
             this.unconditional_fail(
-              `Perma failure '${mf[0]}' has never been hit`
+              `Perma failure '${mf[0]}' has never been hit`,
             );
           }
         }
@@ -192,7 +190,7 @@ class Core {
     if (
       !this.timeout &&
       this.expectedFailures.find(
-        v => v.group == this.currgroup && v.type == 'perma'
+        v => v.group == this.currgroup && v.type == 'perma',
       )
     ) {
       return 1;
@@ -204,45 +202,26 @@ class Core {
 let primeCore = new Core();
 let currentCore = primeCore;
 
-module.exports = {
-  Core,
+export { Core };
 
-  info(...args) {
-    return currentCore.info(...args);
-  },
-  assert(...args) {
-    return currentCore.assert(...args);
-  },
-  not_reached(...args) {
-    return currentCore.not_reached(...args);
-  },
-  group(...args) {
-    return currentCore.group(...args);
-  },
-  fail(...args) {
-    return currentCore.fail(...args);
+export const testflow = {
+  lock({ core, timeout } = {}) {
+    currentCore = core || new Core(timeout);
   },
-  todo(...args) {
-    return currentCore.todo(...args);
-  },
-  warn(...args) {
-    return currentCore.warn(...args);
-  },
-  success(...args) {
-    return currentCore.success(...args);
-  },
-
-  failed() {
-    return currentCore.failed();
+  unlock() {
+    currentCore = primeCore;
   },
-
   get core() {
     return currentCore;
   },
-  lock(core) {
-    currentCore = core || new Core();
-  },
-  unlock() {
-    currentCore = primeCore;
-  },
 };
+
+export const assert = (...args) => currentCore.assert(...args);
+export const info = (...args) => currentCore.info(...args);
+export const not_reached = (...args) => currentCore.not_reached(...args);
+export const group = (...args) => currentCore.group(...args);
+export const fail = (...args) => currentCore.fail(...args);
+export const todo = (...args) => currentCore.todo(...args);
+export const warn = (...args) => currentCore.warn(...args);
+export const success = (...args) => currentCore.success(...args);
+export const failed = () => currentCore.failed();

package/core/format.js

@@ -1,4 +1,4 @@
-'use strict';
+const esc_char = ''; // \x1b
 
 const colors = {
   group: '36',
@@ -13,17 +13,17 @@ const colors = {
   intermittents: '105',
   todos: '103',
   warnings: '103',
-  failures: '41m\x1b[37',
+  failures: `41m${esc_char}[37`,
   success: '102',
 };
 
 const codes = new Map(
-  Array.from(Object.keys(colors)).map(key => [colors[key], key])
+  Array.from(Object.keys(colors)).map(key => [colors[key], key]),
 );
 
 // Colorifies the message.
 function colorify(color, label, msg) {
-  return `\x1b[${colors[color]}m${label}\x1b[0m ${msg}`;
+  return `${esc_char}[${colors[color]}m${label}${esc_char}[0m ${msg}`;
 }
 
 // Parses the given message.
@@ -53,60 +53,100 @@ function parse_failure(str) {
   return null;
 }
 
-module.exports = {
-  colorify,
-  parse,
-  parse_failure,
+function format_started(msg) {
+  return colorify('started', 'Started', msg);
+}
+
+function format_completed(msg) {
+  return colorify('completed', 'Completed', msg);
+}
+
+function format_intermittent(msg) {
+  return colorify('intermittent', 'Intermittent:', msg);
+}
+
+function format_intermittents(count, context) {
+  let label = context ? `${context} > intermittents` : 'Intermittents';
+  return colorify('intermittents', label, `Total: ${count}`);
+}
 
-  format_started(msg) {
-    return colorify('started', 'Started', msg);
-  },
-  format_completed(msg) {
-    return colorify('completed', 'Completed', msg);
-  },
-  format_intermittent(msg) {
-    return colorify('intermittent', 'Intermittent:', msg);
-  },
-  format_intermittents(count, context) {
-    let label = context ? `${context} > intermittents` : 'Intermittents';
-    return colorify('intermittents', label, `Total: ${count}`);
-  },
-  format_failure(msg, label) {
-    return colorify('failure', label || 'Failed:', msg);
-  },
-  format_failures(count, context_or_okcount, context) {
-    if (typeof context_or_okcount == 'string') {
-      return colorify(
-        'failures',
-        `>${context_or_okcount}`,
-        `Failure count: ${count}`
-      );
-    }
-    let label = !context ? 'Failed!' : `${context} > failed`;
+function format_failure(msg, label) {
+  return colorify('failure', label || 'Failed:', msg);
+}
+
+function format_failures(count, context_or_okcount, context) {
+  if (typeof context_or_okcount == 'string') {
     return colorify(
       'failures',
-      label,
-      `Passed: ${context_or_okcount}. Failed: ${count}`
+      `>${context_or_okcount}`,
+      `Failure count: ${count}`,
     );
-  },
-  format_ok(msg) {
-    return colorify('ok', 'Ok:', msg);
-  },
-  format_success(okcount, context) {
-    return colorify('success', context || 'Success!', `Total: ${okcount}`);
-  },
-  format_todo(msg) {
-    return colorify('todo', 'Todo:', msg);
-  },
-  format_todos(count, context) {
-    let label = context ? `${context} > todos` : 'Todos';
-    return colorify('todos', label, `Total: ${count}`);
-  },
-  format_warning(msg) {
-    return colorify('warning', 'Warning:', msg);
-  },
-  format_warnings(count, context) {
-    let label = context ? `${context} > warnings` : 'Warnings';
-    return colorify('warnings', label, `Total: ${count}`);
-  },
+  }
+  let label = !context ? 'Failed!' : `${context} > failed`;
+  return colorify(
+    'failures',
+    label,
+    `Passed: ${context_or_okcount}. Failed: ${count}`,
+  );
+}
+
+function format_ok(msg) {
+  return colorify('ok', 'Ok:', msg);
+}
+
+function format_success(okcount, context) {
+  return colorify('success', context || 'Success!', `Total: ${okcount}`);
+}
+
+function format_todo(msg) {
+  return colorify('todo', 'Todo:', msg);
+}
+
+function format_todos(count, context) {
+  let label = context ? `${context} > todos` : 'Todos';
+  return colorify('todos', label, `Total: ${count}`);
+}
+
+function format_warning(msg) {
+  return colorify('warning', 'Warning:', msg);
+}
+
+function format_warnings(count, context) {
+  let label = context ? `${context} > warnings` : 'Warnings';
+  return colorify('warnings', label, `Total: ${count}`);
+}
+
+// Node v20 wraps stderr by '\[31m' and '\[39m' characters.
+function stderr_wrap(s) {
+  return `${s}`;
+}
+
+function stderr_unwrap(s) {
+  // eslint-disable-next-line no-control-regex
+  return s.replace(/\[31m(.*?)\[39m(\n?)/gs, '$1$2');
+}
+
+function stderr_format_failure(...args) {
+  return stderr_wrap(format_failure(...args));
+}
+
+export {
+  colorify,
+  parse,
+  parse_failure,
+  format_started,
+  format_completed,
+  format_intermittent,
+  format_intermittents,
+  format_failure,
+  format_failures,
+  format_ok,
+  format_success,
+  format_todo,
+  format_todos,
+  format_warning,
+  format_warnings,
+  stderr_wrap,
+  stderr_unwrap,
+  stderr_format_failure,
 };

package/core/process_args.js

@@ -1,5 +1,3 @@
-'use strict';
-
 class ProcessArgs {
   static asObject() {
     let obj = {
@@ -68,6 +66,4 @@ class ProcessArgs {
   }
 }
 
-module.exports = {
-  ProcessArgs,
-};
+export { ProcessArgs };