@camperaid/watest 2.5.3 → 2.5.5

package/core/process-args.js

@@ -44,6 +44,11 @@ class ProcessArgs {
           obj.rootFolder = process.argv[++i];
           break;
 
+        case '--rerun':
+          // Rerun suffix appended to first folder level (e.g., --rerun 5 → www becomes www-5)
+          obj.rerun = process.argv[++i];
+          break;
+
         case '--input-type=module':
           break;
 
@@ -70,6 +75,10 @@ class ProcessArgs {
     } else if ('verify' in args) {
       list.push('--verify');
     }
+    // Pass rerun suffix to child processes
+    if ('rerun' in args) {
+      list.push('--rerun', args.rerun);
+    }
     return list;
   }
 }

package/core/series.js

@@ -76,6 +76,7 @@ class Series {
     {
       debunk,
       invocation,
+      rerun,
       skipOnFail,
       timeout,
       verify,
@@ -90,6 +91,7 @@ class Series {
   ) {
     this.debunk = debunk;
     this.invocation = invocation || settings.invocation;
+    this.rerun = rerun;
     this.patterns = patterns;
     this.skipOnFail = skipOnFail;
     this.verify = verify;
@@ -140,9 +142,9 @@ class Series {
         await this.runFor(this.patterns.map(p => ({ path: p, webdriver: '' })));
       }
     } else {
-      // In very mode, re-run all failing tests.
+      // In verify mode, re-run all failing tests.
       if (this.verify && this.failures.length > 0) {
-        await this.runFor(this.failures, '2');
+        await this.runFor(this.failures, '-verify');
       }
     }
     log(`Elapsed: ${Date.now() - start_time}ms`);
@@ -158,11 +160,23 @@ class Series {
       virtual_folder: this.invocation,
     });
 
-    // Adjust names.
+    // Adjust names for verify mode (appends postfix like "2").
     if (name_postfix) {
       this.adjustTestNames(tests, name_postfix);
     }
 
+    // Apply rerun suffix to first folder level (e.g., --rerun 5 → www becomes www-5).
+    if (this.rerun) {
+      // Extract numeric ID if the argument includes a prefix (e.g. "www-12" -> "12")
+      let suffix = this.rerun;
+      // Match hyphen + digits at end of string
+      const match = suffix.match(/-(\d+)$/);
+      if (match) {
+        suffix = match[1];
+      }
+      this.applyRerunSuffix(tests, suffix);
+    }
+
     if (tests.length == 0) {
       log(
         colorify(
@@ -486,13 +500,17 @@ class Series {
         testname: path,
       });
 
-      tests.push({
+      const testObj = {
         name,
         path,
         func: test_wrap,
         webdriver,
         failures_info,
-      });
+      };
+      if (test_module.timeout) {
+        testObj.timeout = test_module.timeout;
+      }
+      tests.push(testObj);
     }
 
     // Add tests from subfolders.
@@ -586,6 +604,20 @@ class Series {
     }
   }
 
+  /**
+   * Apply rerun suffix to the first folder level in test names.
+   * e.g., --rerun 5 transforms linux/www/test → linux/www-5/test
+   */
+  applyRerunSuffix(tests, suffix) {
+    for (let test of tests) {
+      // Match first folder after invocation: linux/www/ → linux/www-5/
+      test.name = test.name.replace(/^([^/]+\/[^/]+)(\/|$)/, `$1-${suffix}$2`);
+      if (test.subtests) {
+        this.applyRerunSuffix(test.subtests, suffix);
+      }
+    }
+  }
+
   /**
    * Runs the tests.
    */
@@ -625,6 +657,7 @@ class Series {
         skip_on_fail,
         run_in_child_process,
         init_or_uninit,
+        timeout,
       } = test;
 
       if (stop && !name.endsWith('uninit')) {
@@ -650,6 +683,7 @@ class Series {
 
       // Invoke a test.
       log(`\n!Running: ${name}, path: ${path}\n`);
+
       let start_time = new Date();
       let kungFuDeathGrip = null;
       let kungFuDeathGripResolve = null;
@@ -667,21 +701,23 @@ class Series {
       try {
         this.core.setExpectedFailures(failures_info);
 
-        // If timeout is given then race it against the test.
-        if (settings.timeout) {
+        // If timeout is given (from meta.js or settings) then race it against the test.
+        const effectiveTimeout = timeout ?? settings.timeout;
+        if (effectiveTimeout) {
+          const timeoutMs = effectiveTimeout * 1000;
           kungFuDeathGrip = new Promise(
             resolve => (kungFuDeathGripResolve = resolve),
           ).then(value => {
             if (value != kKungFuDeathGripCancelled) {
               fail(
-                `Test ${name} takes longer than ${settings.timeout}ms. It's either slow or never ends.`,
+                `Test ${name} takes longer than ${effectiveTimeout}s. It's either slow or never ends.`,
               );
               return kKungFuDeathGripTimeout;
             }
           });
           kungFuDeathGripTimer = setTimeout(
             kungFuDeathGripResolve,
-            settings.timeout,
+            timeoutMs,
           );
           let retval = await Promise.race([func(), kungFuDeathGrip]);
           if (retval != kKungFuDeathGripTimeout) {

package/core/settings.js

@@ -54,11 +54,11 @@ class Settings {
   }
 
   get testFilePattern() {
-    return this.rc.test_file_pattern || /^t[-_]/;
+    return this.rc?.test_file_pattern || /^t[-_]/;
   }
 
   get timeout() {
-    return parseInt(this.rc.timeout) || 0;
+    return parseInt(this.rc?.timeout) || 0;
   }
 
   setupTmpStorageDir() {

package/core/util.js

@@ -98,12 +98,29 @@ function removeDir(path) {
   }
 }
 
-function is_mac() {
+function isMac() {
   return process.platform == 'darwin';
 }
 
+function isLinux() {
+  return process.platform == 'linux';
+}
+
+function isWin() {
+  return process.platform == 'win32';
+}
+
 function toDataURL(html) {
   return `data:text/html,${querystring.escape(html)}`;
 }
 
-export { inspect, stringify, is_mac, toDataURL, removeDir, initTmpStorage };
+export {
+  inspect,
+  stringify,
+  isMac,
+  isLinux,
+  isWin,
+  toDataURL,
+  removeDir,
+  initTmpStorage,
+};

package/index.js

@@ -23,7 +23,7 @@ import {
 } from './core/base.js';
 
 import { settings } from './core/settings.js';
-import { inspect } from './core/util.js';
+import { inspect, isMac, isLinux, isWin } from './core/util.js';
 import { AppDriver } from './webdriver/app-driver.js';
 import { ControlDriver } from './webdriver/control-driver.js';
 import { start_session, scope } from './webdriver/session.js';
@@ -48,6 +48,9 @@ export {
   is_output,
   info,
   inspect,
+  isLinux,
+  isMac,
+  isWin,
   not_reached,
   no_throws,
   ok,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camperaid/watest",
-  "version": "2.5.3",
+  "version": "2.5.5",
   "description": "Web Application Testsuite",
   "type": "module",
   "engines": {

package/tests/series/build/t-rerun-suffix.js

@@ -0,0 +1,66 @@
+import { is, MockSeries } from '../test.js';
+
+export async function test() {
+  const test = got => got.name == 'test_wrap';
+  const ts = {
+    'www': {
+      meta: {
+        folders: ['ui', 'api'],
+      },
+    },
+    'www/ui': {
+      files: ['t_login.js'],
+    },
+    'www/ui/t_login.js': {
+      test() {},
+    },
+    'www/api': {
+      files: ['t_search.js'],
+    },
+    'www/api/t_search.js': {
+      test() {},
+    },
+  };
+
+  const series = new MockSeries([], { ts });
+  const tests = await series.build({
+    patterns: [],
+    folder: 'www',
+    virtual_folder: 'linux/www',
+  });
+  series.applyRerunSuffix(tests, '5');
+  series.shutdown();
+
+  is(
+    tests,
+    [
+      {
+        name: 'linux/www-5/ui',
+        path: 'www/ui/',
+        subtests: [
+          {
+            name: 'linux/www-5/ui/t_login.js',
+            path: 'www/ui/t_login.js',
+            func: test,
+            failures_info: [],
+            webdriver: '',
+          },
+        ],
+      },
+      {
+        name: 'linux/www-5/api',
+        path: 'www/api/',
+        subtests: [
+          {
+            name: 'linux/www-5/api/t_search.js',
+            path: 'www/api/t_search.js',
+            func: test,
+            failures_info: [],
+            webdriver: '',
+          },
+        ],
+      },
+    ],
+    'rerun suffix transforms linux/www → linux/www-5',
+  );
+}

package/tests/series/logging/t-verify.js

@@ -93,16 +93,16 @@ export async function test() {
           ],
         ],
         [
-          'mac/webdriver/chrome/end-to-end/history2/log',
+          'mac/webdriver/chrome/end-to-end/history-verify/log',
           [
-            '\x1B[38;5;99mStarted\x1B[0m mac/webdriver/chrome/end-to-end/history2',
-            '!Running: mac/webdriver/chrome/end-to-end/history2/t_history.js, path: tests/webdriver/end-to-end/history/t_history.js',
+            '\x1B[38;5;99mStarted\x1B[0m mac/webdriver/chrome/end-to-end/history-verify',
+            '!Running: mac/webdriver/chrome/end-to-end/history-verify/t_history.js, path: tests/webdriver/end-to-end/history/t_history.js',
             '\x1B[32mOk:\x1B[0m TestoOk',
             completed_in(
-              'mac/webdriver/chrome/end-to-end/history2/t_history.js',
+              'mac/webdriver/chrome/end-to-end/history-verify/t_history.js',
             ),
-            '\x1B[102mmac/webdriver/chrome/end-to-end/history2\x1B[0m Total: 1',
-            '\x1B[38;5;243mCompleted\x1B[0m mac/webdriver/chrome/end-to-end/history2',
+            '\x1B[102mmac/webdriver/chrome/end-to-end/history-verify\x1B[0m Total: 1',
+            '\x1B[38;5;243mCompleted\x1B[0m mac/webdriver/chrome/end-to-end/history-verify',
           ],
         ],
       ]

package/tests/series/perform/t-timeout.js

@@ -0,0 +1,107 @@
+import { is_test_output } from '../test.js';
+import { success } from '../../../core/core.js';
+import { Core } from '../../../core/core.js';
+import { Series } from '../../../core/series.js';
+
+class MockLogPipe {
+  attach() {
+    return Promise.resolve();
+  }
+  release() {
+    return Promise.resolve();
+  }
+  logToFile() {}
+}
+
+function make_perform_with_timeout(tests) {
+  return async () => {
+    const series = new Series('tests/', {
+      core: new Core(),
+      LogPipe: new MockLogPipe(),
+    });
+    try {
+      await series.perform({ folder: 'tests/', tests });
+    } finally {
+      series.shutdown();
+    }
+  };
+}
+
+export async function test() {
+  // Test that timeout from meta.js causes test to fail after specified time
+  await is_test_output(
+    make_perform_with_timeout([
+      {
+        name: 't-slow.js',
+        path: 'tests/t-slow.js',
+        func: () => new Promise(resolve => setTimeout(resolve, 500)),
+        failures_info: [],
+        timeout: 0.05, // 50ms timeout in seconds
+      },
+    ]),
+    [
+      '\x1B[38;5;99mStarted\x1B[0m tests/',
+      '!Running: t-slow.js, path: tests/t-slow.js',
+      '>t-slow.js completed in',
+      '\x1B[38;5;243mCompleted\x1B[0m tests/',
+      'Testsuite: shutdown',
+    ],
+    [
+      "\x1B[31mFailed:\x1B[0m Test t-slow.js takes longer than 0.05s. It's either slow or never ends.",
+      '\x1B[31m>t-slow.js\x1B[0m has 1 failure(s)',
+    ],
+    'meta timeout causes test to fail',
+  );
+
+  // Test that test completes normally when timeout is not exceeded
+  await is_test_output(
+    make_perform_with_timeout([
+      {
+        name: 't-fast.js',
+        path: 'tests/t-fast.js',
+        func: () => {
+          success('fast test passes');
+          return Promise.resolve();
+        },
+        failures_info: [],
+        timeout: 1, // 1 second timeout
+      },
+    ]),
+    [
+      '\x1B[38;5;99mStarted\x1B[0m tests/',
+      '!Running: t-fast.js, path: tests/t-fast.js',
+      '\x1B[32mOk:\x1B[0m fast test passes',
+      '>t-fast.js completed in',
+      '\x1B[38;5;243mCompleted\x1B[0m tests/',
+      'Testsuite: shutdown',
+    ],
+    [],
+    'test completes within timeout',
+  );
+
+  // Test that no timeout applies when timeout is undefined
+  await is_test_output(
+    make_perform_with_timeout([
+      {
+        name: 't-no-timeout.js',
+        path: 'tests/t-no-timeout.js',
+        func: () => {
+          success('no timeout test passes');
+          return new Promise(resolve => setTimeout(resolve, 10));
+        },
+        failures_info: [],
+        // timeout: undefined - no timeout set
+      },
+    ]),
+    [
+      '\x1B[38;5;99mStarted\x1B[0m tests/',
+      '!Running: t-no-timeout.js, path: tests/t-no-timeout.js',
+      '\x1B[32mOk:\x1B[0m no timeout test passes',
+      '>t-no-timeout.js completed in',
+      '\x1B[38;5;243mCompleted\x1B[0m tests/',
+      'Testsuite: shutdown',
+    ],
+    [],
+    'test runs without timeout when not specified',
+  );
+}

package/tests/series/run/t-verify-webdriver.js

@@ -69,11 +69,11 @@ export async function test() {
     '\x1B[38;5;99mStarted\x1B[0m mac/webdriver',
     '\x1B[38;5;99mStarted\x1B[0m mac/webdriver/chrome',
     '\x1B[38;5;99mStarted\x1B[0m mac/webdriver/chrome/end-to-end',
-    '\x1B[38;5;99mStarted\x1B[0m mac/webdriver/chrome/end-to-end/sharing2',
-    '!Running: mac/webdriver/chrome/end-to-end/sharing2/t_shared_editing.js, path: tests/webdriver/end-to-end/sharing/t_shared_editing.js',
+    '\x1B[38;5;99mStarted\x1B[0m mac/webdriver/chrome/end-to-end/sharing-verify',
+    '!Running: mac/webdriver/chrome/end-to-end/sharing-verify/t_shared_editing.js, path: tests/webdriver/end-to-end/sharing/t_shared_editing.js',
     '\x1B[32mOk:\x1B[0m WDSuccessio',
-    '>mac/webdriver/chrome/end-to-end/sharing2/t_shared_editing.js completed in',
-    '\x1B[38;5;243mCompleted\x1B[0m mac/webdriver/chrome/end-to-end/sharing2',
+    '>mac/webdriver/chrome/end-to-end/sharing-verify/t_shared_editing.js completed in',
+    '\x1B[38;5;243mCompleted\x1B[0m mac/webdriver/chrome/end-to-end/sharing-verify',
     'Logs are written to',
     '\x1B[38;5;243mCompleted\x1B[0m mac/webdriver/chrome/end-to-end',
     'Logs are written to',

package/tests/series/run/t-verify.js

@@ -55,14 +55,14 @@ export async function test() {
     'Logs are written to',
     '\x1B[38;5;99mStarted\x1B[0m mac/',
     '\x1B[38;5;99mStarted\x1B[0m mac/unit',
-    '\x1B[38;5;99mStarted\x1B[0m mac/unit/core2',
-    '!Running: mac/unit/core2/t_presto.js, path: tests/unit/core/t_presto.js',
-    '>mac/unit/core2/t_presto.js completed in',
-    '\x1B[38;5;243mCompleted\x1B[0m mac/unit/core2',
+    '\x1B[38;5;99mStarted\x1B[0m mac/unit/core-verify',
+    '!Running: mac/unit/core-verify/t_presto.js, path: tests/unit/core/t_presto.js',
+    '>mac/unit/core-verify/t_presto.js completed in',
+    '\x1B[38;5;243mCompleted\x1B[0m mac/unit/core-verify',
     'Logs are written to',
     '\x1B[38;5;243mCompleted\x1B[0m mac/unit',
     'Logs are written to',
-    '\x1B[41m\x1B[37m>mac/unit/core2/t_presto.js\x1B[0m Failure count: 1',
+    '\x1B[41m\x1B[37m>mac/unit/core-verify/t_presto.js\x1B[0m Failure count: 1',
     '\x1B[41m\x1B[37mFailed!\x1B[0m Passed: 0. Failed: 1',
     '\x1B[38;5;243mCompleted\x1B[0m mac/',
     'Logs are written to',
@@ -75,7 +75,7 @@ export async function test() {
     '\x1B[31mFailed:\x1B[0m Presto',
     '\x1B[31m>mac/unit/core/t_presto.js\x1B[0m has 1 failure(s)',
     '\x1B[31mFailed:\x1B[0m Presto',
-    '\x1B[31m>mac/unit/core2/t_presto.js\x1B[0m has 1 failure(s)',
+    '\x1B[31m>mac/unit/core-verify/t_presto.js\x1B[0m has 1 failure(s)',
   ];
 
   await is_test_output(

package/webdriver/driver-base.js

@@ -30,7 +30,7 @@ function getChromeOptions() {
     height: settings.webdriver_window_height,
   });
   if (settings.webdriver_headless) {
-    chromeOptions.addArguments('headless');
+    chromeOptions.addArguments('headless=new');
   }
   if (settings.webdriver == 'chrome-mobile') {
     chromeOptions.setMobileEmulation({

package/webdriver/driver.js

@@ -1,7 +1,7 @@
 import { By, Condition, Key, until } from 'selenium-webdriver';
 import { test_is, test_contains, is, contains, ok } from '../core/base.js';
 import { assert, fail } from '../core/core.js';
-import { is_mac, stringify, toDataURL } from '../core/util.js';
+import { isMac, stringify, toDataURL } from '../core/util.js';
 import { log } from '../logging/logging.js';
 import { getTimeout, DriverBase } from './driver-base.js';
 
@@ -841,7 +841,7 @@ class Driver extends DriverBase {
     assert(msg, `selectAll: no msg`);
 
     if (this.firefox) {
-      let accel = (is_mac() && Key.COMMAND) || Key.CONTROL;
+      let accel = (isMac() && Key.COMMAND) || Key.CONTROL;
       return this.waitForElementToInvoke(
         selector,
         el => el.sendKeys(Key.chord(accel, 'a')),

package/webdriver/session.js

@@ -1,6 +1,7 @@
 import { assert, group, fail, info } from '../core/core.js';
 import { log, log_error } from '../logging/logging.js';
 import { Driver } from './driver.js';
+import { isMac, isLinux, isWin } from '../core/util.js';
 
 let active_sessions = [];
 
@@ -113,6 +114,12 @@ async function start_session(arg1, arg2) {
 
   s.isSafari = () => s.driver.safari;
 
+  s.isMac = () => isMac();
+
+  s.isLinux = () => isLinux();
+
+  s.isWin = () => isWin();
+
   /**
    * Pause the session for number of secs.
    */