@camperaid/watest 2.4.7 → 2.4.9

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.
@@ -34,6 +32,12 @@ const cfg = {
    */
   webdriver_headless: process.env.WATEST_WEBDRIVER_HEADLESS,
 
+  /**
+   *  Web driver window size.
+   */
+  webdriver_window_width: process.env.WATEST_WEBDRIVER_WINDOW_WIDTH,
+  webdriver_window_height: process.env.WATEST_WEBDRIVER_WINDOW_HEIGHT,
+
   /**
    * Web driver log level.
    */
@@ -61,4 +65,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,53 +542,72 @@ 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;
 }
 
 function throws(func, exception, msg) {
-  try {
-    func();
-    fail(`${msg}: no '${exception}' exception`);
-  } catch (e) {
-    is(e?.message, exception, msg);
-  }
+  const on_no_exception = () => fail(`${msg}: no '${exception}' exception`);
+  const on_exception = e => is(e?.message, exception, msg);
+  return throw_internal(func, on_no_exception, on_exception);
 }
 
 function no_throws(func, msg) {
-  try {
-    func();
-    success(msg);
-  } catch (e) {
+  const on_no_exception = () => success(msg);
+  const on_exception = e => {
     log_error(e);
     fail(`${msg}, got: ${e?.message ?? ''} exception`);
+  };
+  return throw_internal(func, on_no_exception, on_exception);
+}
+
+function throw_internal(func, on_no_exception, on_exception) {
+  try {
+    const result = func();
+
+    // If result is a Promise, handle it asynchronously
+    if (result && typeof result.then === 'function') {
+      return result.then(on_no_exception, on_exception);
+    }
+
+    // Sync function completed successfully (no exception)
+    on_no_exception();
+  } catch (e) {
+    // Sync function threw an exception
+    on_exception(e);
+  }
+}
+
+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]}'`);
   }
 }
 
-module.exports = {
+export {
   success,
   fail,
   failed,
-
   ok,
   is,
   contains,
@@ -599,13 +616,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();