@camperaid/watest 2.4.12 → 2.5.1

package/core/base.js

@@ -551,9 +551,16 @@ function is_out(got, expected, msg) {
   return false;
 }
 
-function throws(func, exception, msg) {
-  const on_no_exception = () => fail(`${msg}: no '${exception}' exception`);
-  const on_exception = e => is(e?.message, exception, msg);
+function throws(func, expected, msg) {
+  const on_no_exception = () => fail(`${msg}: no '${expected}' exception`);
+  const on_exception = e =>
+    is(
+      expected instanceof RegExp || typeof expected === 'string'
+        ? e?.message
+        : e,
+      expected,
+      msg,
+    );
   return throw_internal(func, on_no_exception, on_exception);
 }
 

package/core/series.js

@@ -145,9 +145,6 @@ class Series {
         await this.runFor(this.failures, '2');
       }
     }
-
-    await settings.servicer.shutdown();
-
     log(`Elapsed: ${Date.now() - start_time}ms`);
   }
 
@@ -181,6 +178,7 @@ class Series {
   }
 
   shutdown() {
+    console.log(`Testsuite: shutdown`);
     testflow.unlock();
     return this.failures.length > 0 ? this.failures : null;
   }
@@ -367,8 +365,24 @@ class Series {
       return [];
     }
 
+    // Filter subfolders to only process those that match the patterns
+    let filteredSubfolders = subfolders;
+    if (patterns.length > 0) {
+      filteredSubfolders = subfolders.filter(subfolder => {
+        const subfolderPath = `${folder}/${subfolder}`;
+        return (
+          this.matchedPatterns({
+            path: subfolderPath,
+            webdriver,
+            patterns,
+            path_is_not_final: true,
+          }).length > 0
+        );
+      });
+    }
+
     let subtests_for_subfolders = await Promise.all(
-      subfolders.map(subfolder =>
+      filteredSubfolders.map(subfolder =>
         this.build({
           patterns,
           folder: `${folder}/${subfolder}`,
@@ -428,13 +442,21 @@ class Series {
       test_module.expected_failures || [],
     );
 
-    // Initialize
+    // Set services if given.
+    if (test_module.servicer) {
+      if (this.#servicerType) {
+        throw new Error(`No nested servicers are supported`);
+      }
+      this.#servicerType = test_module.servicer;
+    }
+
+    // Initialize.
     if (test_module.services || test_module.init) {
       let init = async () => {
         // Start services if any.
         let chain = Promise.resolve();
         for (let service of test_module.services || []) {
-          chain = chain.then(() => settings.servicer.start(service));
+          chain = chain.then(() => this.getServicer().start(service));
         }
         await chain;
 
@@ -460,7 +482,7 @@ class Series {
       // A function to notify the servicer the test is about to start and then
       // to invoke the test.
       const test_wrap = () =>
-        Promise.resolve(settings.servicer.ontest(name)).then(test);
+        Promise.resolve(this.#servicer?.ontest(name)).then(test);
 
       let failures_info = Series.failuresInfo({
         failures: expected_failures,
@@ -494,8 +516,13 @@ class Series {
         await Promise.all(
           [...(test_module.services || [])]
             .reverse()
-            .map(s => settings.servicer.stop(s)),
+            .map(s => this.getServicer().stop(s)),
         );
+
+        // Clean up service-level servicer
+        await this.#servicer?.shutdown();
+        this.#servicer = null;
+        this.#servicerType = null;
       };
       tests.push({
         name: `${virtual_folder}/uninit`,
@@ -641,6 +668,16 @@ class Series {
       let kungFuDeathGrip = null;
       let kungFuDeathGripResolve = null;
       let kungFuDeathGripTimer = 0;
+
+      // Take snapshots before the test runs
+      const testSnapshots = {
+        fcnt: this.core.failureCount,
+        icnt: this.core.intermittentCount,
+        tcnt: this.core.todoCount,
+        wcnt: this.core.warningCount,
+        ocnt: this.core.okCount,
+      };
+
       try {
         this.core.setExpectedFailures(failures_info);
 
@@ -687,6 +724,7 @@ class Series {
           init_or_uninit,
           path,
           webdriver,
+          snapshots: testSnapshots,
         });
 
         // If failed, then stop running the current tests.
@@ -715,12 +753,12 @@ class Series {
     await this.LogPipe.release();
   }
 
-  recordStats({ name, init_or_uninit, path, webdriver }) {
+  recordStats({ name, init_or_uninit, path, webdriver, snapshots }) {
     let hasChanged = false;
     let hasFailures = false;
 
     // Record intermittents.
-    let delta = this.core.intermittentCount - this.icnt;
+    let delta = this.core.intermittentCount - snapshots.icnt;
     if (delta > 0) {
       log(`>${name} has ${delta} intermittent(s)`);
       this.icnt = this.core.intermittentCount;
@@ -728,7 +766,7 @@ class Series {
     }
 
     // Record todos.
-    delta = this.core.todoCount - this.tcnt;
+    delta = this.core.todoCount - snapshots.tcnt;
     if (delta > 0) {
       log(`>${name} has ${delta} todo(s)`);
       this.tcnt = this.core.todoCount;
@@ -736,7 +774,7 @@ class Series {
     }
 
     // Record warnings.
-    delta = this.core.warningCount - this.wcnt;
+    delta = this.core.warningCount - snapshots.wcnt;
     if (delta > 0) {
       log(`>${name} has ${delta} warnings(s)`);
       this.wcnt = this.core.warningCount;
@@ -744,14 +782,14 @@ class Series {
     }
 
     // Record successful test count.
-    delta = this.core.okCount - this.ocnt;
+    delta = this.core.okCount - snapshots.ocnt;
     if (delta > 0) {
       this.ocnt = this.core.okCount;
       hasChanged = true;
     }
 
     // Fail if no changes.
-    delta = this.core.failureCount - this.fcnt;
+    delta = this.core.failureCount - snapshots.fcnt;
     if (!init_or_uninit) {
       if (delta == 0 && !hasChanged) {
         delta = 1;
@@ -908,7 +946,10 @@ class Series {
     let args = [];
     if (loader) {
       // Use the new --import flag with register() API instead of deprecated --loader
-      args.push('--import', `data:text/javascript,import { register } from "node:module"; import { pathToFileURL } from "node:url"; register("${loader}", pathToFileURL("./"));`);
+      args.push(
+        '--import',
+        `data:text/javascript,import { register } from "node:module"; import { pathToFileURL } from "node:url"; register("${loader}", pathToFileURL("./"));`,
+      );
     }
     const watest_bin = nodepath.join(__dirname, '../bin/watest.js');
     args.push(
@@ -1018,6 +1059,20 @@ class Series {
       }
     }
   }
+
+  getServicer() {
+    if (!this.#servicer) {
+      this.#servicer = this.createServicer(this.#servicerType);
+    }
+    return this.#servicer;
+  }
+
+  createServicer(servicerType) {
+    return settings.getServicer(servicerType);
+  }
+
+  #servicer;
+  #servicerType;
 }
 
 export { Series };

package/core/settings.js

@@ -16,7 +16,7 @@ class Settings {
       await import(this.rc.logger || '../interfaces/logger.js')
     ).default;
 
-    this.servicer = (
+    this.getServicer = (
       await import(this.rc.servicer || '../interfaces/servicer.js')
     ).default;
 

package/core/system.js

@@ -0,0 +1,68 @@
+import { spawn } from './spawn.js';
+
+/**
+ * Run a shell command and capture its output
+ * @param {string} cmd - Command to run
+ * @param {string[]} args - Command arguments
+ * @param {object} options - Spawn options
+ * @returns {Promise<{stdout: string, stderr: string, exitCode: number, stdoutLines: string[], stderrLines: string[]}>}
+ */
+export async function runCommand(cmd, args = [], options = {}) {
+  let stdout = [];
+  let stderr = [];
+  let exitCode = 0;
+
+  try {
+    exitCode = await spawn(cmd, args, options, buffer => {
+      for (let { str_data, is_stdout } of buffer) {
+        const lines = str_data.split('\n').filter(line => line);
+        if (is_stdout) {
+          stdout.push(...lines);
+        } else {
+          stderr.push(...lines);
+        }
+      }
+    });
+  } catch (code) {
+    exitCode = code;
+  }
+
+  return {
+    stdout: stdout.join('\n'),
+    stderr: stderr.join('\n'),
+    exitCode,
+    stdoutLines: stdout,
+    stderrLines: stderr,
+  };
+}
+
+/**
+ * Run a bash script with proper error handling
+ * @param {string} script - Bash script content
+ * @param {string[]} args - Script arguments
+ * @param {object} options - Spawn options
+ * @returns {Promise<{stdout: string, stderr: string, exitCode: number, stdoutLines: string[], stderrLines: string[]}>}
+ */
+export async function runBashScript(script, args = [], options = {}) {
+  return runCommand('bash', ['-c', script, '--', ...args], options);
+}
+
+/**
+ * Run a shell command and return only stdout (for simple cases)
+ * @param {string} cmd - Command to run
+ * @param {string[]} args - Command arguments
+ * @param {object} options - Spawn options
+ * @returns {Promise<string>} stdout content
+ */
+export async function execCommand(cmd, args = [], options = {}) {
+  const result = await runCommand(cmd, args, options);
+  if (result.exitCode !== 0) {
+    throw new Error(
+      `Command failed with exit code ${result.exitCode}: ${result.stderr}`,
+    );
+  }
+  return result.stdout;
+}
+
+// Export the raw spawn function for advanced use cases
+export { spawn };

package/eslint.config.js

@@ -6,7 +6,7 @@ export default [
   nodePlugin.configs['flat/recommended-script'],
   {
     languageOptions: {
-      ecmaVersion: 2021,
+      ecmaVersion: 2022,
       sourceType: 'module',
     },
   },

package/index.js

@@ -26,12 +26,19 @@ import { inspect } 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';
+import {
+  runCommand,
+  runBashScript,
+  execCommand,
+  spawn,
+} from './core/system.js';
 
 export {
   AppDriver,
   ControlDriver,
   assert,
   contains,
+  execCommand,
   failed,
   fail,
   group,
@@ -42,7 +49,10 @@ export {
   not_reached,
   no_throws,
   ok,
+  runBashScript,
+  runCommand,
   scope,
+  spawn,
   start_session,
   success,
   todo,

package/interfaces/servicer.js

@@ -16,7 +16,6 @@ class Servicer {
    * Called when the testsuite gets shutdown.
    */
   shutdown() {
-    console.log(`Testsuite: shutdown`);
   }
 
   /**

package/package.json

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

package/tests/base/t_system.js

@@ -0,0 +1,59 @@
+import { ok, contains } from '../../index.js';
+import { runCommand, runBashScript, execCommand } from '../../core/system.js';
+
+export async function test() {
+  // Test 1: runCommand with echo
+  {
+    const result = await runCommand('echo', ['hello', 'world']);
+    ok(result.exitCode === 0, 'echo command should succeed');
+    ok(result.stdout === 'hello world', 'stdout should contain echo output');
+    ok(result.stderr === '', 'stderr should be empty');
+    ok(result.stdoutLines.length === 1, 'should have one stdout line');
+    ok(result.stdoutLines[0] === 'hello world', 'stdout line should match');
+  }
+
+  // Test 2: runBashScript with simple script
+  {
+    const script = 'echo "test script"; echo "line 2"';
+    const result = await runBashScript(script);
+    ok(result.exitCode === 0, 'bash script should succeed');
+    contains(result.stdout, 'test script', 'should contain first echo');
+    contains(result.stdout, 'line 2', 'should contain second echo');
+    ok(result.stdoutLines.length === 2, 'should have two stdout lines');
+  }
+
+  // Test 3: execCommand for simple cases
+  {
+    const output = await execCommand('echo', ['simple test']);
+    ok(output === 'simple test', 'execCommand should return stdout directly');
+  }
+
+  // Test 4: runCommand with failing command
+  {
+    const result = await runCommand('bash', ['-c', 'echo "error" >&2; exit 1']);
+    ok(result.exitCode === 1, 'failing command should return exit code 1');
+    ok(result.stdout === '', 'stdout should be empty');
+    ok(result.stderr === 'error', 'stderr should contain error message');
+  }
+
+  // Test 5: execCommand should throw on failure
+  {
+    let threw = false;
+    try {
+      await execCommand('bash', ['-c', 'exit 1']);
+    } catch (error) {
+      threw = true;
+      contains(error.message, 'exit code 1', 'error should mention exit code');
+    }
+    ok(threw, 'execCommand should throw on non-zero exit code');
+  }
+
+  // Test 6: runBashScript with arguments
+  {
+    const script = 'echo "arg1: $1, arg2: $2"';
+    const result = await runBashScript(script, ['first', 'second']);
+    ok(result.exitCode === 0, 'bash script with args should succeed');
+    contains(result.stdout, 'arg1: first', 'should pass first argument');
+    contains(result.stdout, 'arg2: second', 'should pass second argument');
+  }
+}

package/tests/base/t_throws.js

@@ -136,4 +136,71 @@ unexpected character: '2' at 6 pos, expected: '1' at '' line
     ],
     `no_throws fail (async)`,
   );
+
+  // throws: accept object descriptor (statusCode + JSON body)
+  await is_output(
+    () =>
+      throws(
+        () => {
+          const err = new Error(
+            'HTTP error code 422 for https://api.digitalocean.com/v2/droplets',
+          );
+          err.statusCode = 422;
+          err.responseBody = JSON.stringify({
+            id: 'unprocessable_entity',
+            message: 'You specified an invalid image for Droplet creation.',
+          });
+          throw err;
+        },
+        {
+          statusCode: 422,
+          responseBody: JSON.stringify({
+            id: 'unprocessable_entity',
+            message: 'You specified an invalid image for Droplet creation.',
+          }),
+        },
+        `Throws error descriptor`,
+      ),
+    [
+      `Ok: Throws error descriptor, got: {statusCode: 422, responseBody: '{"id":"unprocessable_entity","message":"You specified an invalid image for Droplet creation."}'}`,
+    ],
+    [],
+    `throws accept object descriptor`,
+  );
+
+  // throws: accept RegExp for message matching
+  await is_output(
+    () =>
+      throws(
+        () => {
+          throw new Error(
+            'Unexpected 404 response code for https://example.com/test from droplet 1',
+          );
+        },
+        /404|Unexpected/,
+        `Throws with RegExp`,
+      ),
+    [
+      `Ok: Throws with RegExp 'Unexpected 404 response code for https://example.com/test from droplet 1' matches /404|Unexpected/ regexp`,
+    ],
+    [],
+    `throws accept RegExp pattern`,
+  );
+
+  // throws: fail RegExp that doesn't match
+  await is_output(
+    () =>
+      throws(
+        () => {
+          throw new Error('Some other error message');
+        },
+        /404|Unexpected/,
+        `RegExp should match`,
+      ),
+    [],
+    [
+      `Failed: RegExp should match 'Some other error message' doesn't match /404|Unexpected/ regexp`,
+    ],
+    `throws fail RegExp no match`,
+  );
 }

package/tests/e2e/t_folder.js

@@ -13,8 +13,8 @@ export async function test() {
       '\x1B[38;5;243mCompleted\x1B[0m sample/unit',
       '\x1B[102mSuccess!\x1B[0m Total: 1',
       '\x1B[38;5;243mCompleted\x1B[0m sample/',
-      'Testsuite: shutdown',
       'Elapsed:',
+      'Testsuite: shutdown',
     ],
     'stdout',
   );

package/tests/e2e/t_loader.js

@@ -11,12 +11,12 @@ export async function test() {
       '\x1B[32mOk:\x1B[0m Mocked!, got: mocked',
       '>sample/t_test.js completed in',
       '\x1B[38;5;243mCompleted\x1B[0m sample/',
-      'Testsuite: shutdown',
       'Elapsed:',
+      'Testsuite: shutdown',
       '\x1B[102mSuccess!\x1B[0m Total: 1',
       '\x1B[38;5;243mCompleted\x1B[0m sample/',
-      'Testsuite: shutdown',
       'Elapsed:',
+      'Testsuite: shutdown',
     ],
     'stdout',
   );

package/tests/e2e/t_loader_mixed.js

@@ -16,12 +16,12 @@ export async function test() {
       '\x1B[32mOk:\x1B[0m Mocked!, got: mocked',
       '>sample/ui/t_test.js completed in',
       '\x1B[38;5;243mCompleted\x1B[0m sample/ui',
-      'Testsuite: shutdown',
       'Elapsed:',
+      'Testsuite: shutdown',
       '\x1B[102mSuccess!\x1B[0m Total: 2',
       '\x1B[38;5;243mCompleted\x1B[0m sample/',
-      'Testsuite: shutdown',
       'Elapsed:',
+      'Testsuite: shutdown',
     ],
     'stdout',
   );

package/tests/e2e/t_loader_multiple.js

@@ -11,19 +11,19 @@ export async function test() {
       '\x1B[32mOk:\x1B[0m Mocked!, got: mocked',
       '>sample/base/t_btest.js completed in',
       '\x1B[38;5;243mCompleted\x1B[0m sample/base',
-      'Testsuite: shutdown',
       'Elapsed:',
+      'Testsuite: shutdown',
       '\x1B[38;5;99mStarted\x1B[0m sample/core',
       '!Running: sample/core/t_ctest.js, path: tests/core/t_ctest.js',
       '\x1B[32mOk:\x1B[0m Mocked!, got: mocked',
       '>sample/core/t_ctest.js completed in',
       '\x1B[38;5;243mCompleted\x1B[0m sample/core',
-      'Testsuite: shutdown',
       'Elapsed:',
+      'Testsuite: shutdown',
       '\x1B[102mSuccess!\x1B[0m Total: 2',
       '\x1B[38;5;243mCompleted\x1B[0m sample/',
-      'Testsuite: shutdown',
       'Elapsed:',
+      'Testsuite: shutdown',
     ],
     'stdout',
   );

package/tests/e2e/t_loader_multiple_patterns.js

@@ -13,19 +13,19 @@ export async function test() {
       '\x1B[32mOk:\x1B[0m Mocked!, got: mocked',
       '>sample/base/t_btest.js completed in',
       '\x1B[38;5;243mCompleted\x1B[0m sample/base',
-      'Testsuite: shutdown',
       'Elapsed:',
+      'Testsuite: shutdown',
       '\x1B[38;5;99mStarted\x1B[0m sample/core',
       '!Running: sample/core/t_ctest.js, path: tests/core/t_ctest.js',
       '\x1B[32mOk:\x1B[0m Mocked!, got: mocked',
       '>sample/core/t_ctest.js completed in',
       '\x1B[38;5;243mCompleted\x1B[0m sample/core',
-      'Testsuite: shutdown',
       'Elapsed:',
+      'Testsuite: shutdown',
       '\x1B[102mSuccess!\x1B[0m Total: 2',
       '\x1B[38;5;243mCompleted\x1B[0m sample/',
-      'Testsuite: shutdown',
       'Elapsed:',
+      'Testsuite: shutdown',
     ],
     'stdout',
   );

package/tests/e2e/t_single.js

@@ -11,8 +11,8 @@ export async function test() {
       '>sample/t_test.js completed in',
       '\x1B[102mSuccess!\x1B[0m Total: 1',
       '\x1B[38;5;243mCompleted\x1B[0m sample/',
-      'Testsuite: shutdown',
       'Elapsed:',
+      'Testsuite: shutdown',
     ],
     'stdout',
   );

package/tests/e2e/t_wd_firefox.js

@@ -13,12 +13,12 @@ export async function test() {
       '\x1B[32mOk:\x1B[0m Webdriver Works!',
       '>sample/firefox/t_test.js completed in',
       '\x1B[38;5;243mCompleted\x1B[0m sample/firefox',
-      'Testsuite: shutdown',
       'Elapsed:',
+      'Testsuite: shutdown',
       '\x1B[102mSuccess!\x1B[0m Total: 1',
       '\x1B[38;5;243mCompleted\x1B[0m sample/',
-      'Testsuite: shutdown',
       'Elapsed:',
+      'Testsuite: shutdown',
     ],
     'stdout',
   );

package/tests/e2e/t_wd_firefox_chrome.js

@@ -13,8 +13,8 @@ export async function test() {
       '\x1B[32mOk:\x1B[0m Webdriver Works!',
       '>sample/firefox/t_test.js completed in',
       '\x1B[38;5;243mCompleted\x1B[0m sample/firefox',
-      'Testsuite: shutdown',
       'Elapsed:',
+      'Testsuite: shutdown',
       '\x1B[38;5;99mStarted\x1B[0m sample/chrome',
       '!Running: sample/chrome/t_test.js, path: tests/t_test.js',
       '\x1B[32mOk:\x1B[0m Webdriver Works!',
@@ -22,8 +22,8 @@ export async function test() {
       '\x1B[38;5;243mCompleted\x1B[0m sample/chrome',
       '\x1B[102mSuccess!\x1B[0m Total: 2',
       '\x1B[38;5;243mCompleted\x1B[0m sample/',
-      'Testsuite: shutdown',
       'Elapsed:',
+      'Testsuite: shutdown',
     ],
     'stdout',
   );

package/tests/e2e/t_wd_firefox_chrome_pattern.js

@@ -14,8 +14,8 @@ export async function test() {
       '\x1B[32mOk:\x1B[0m Webdriver Works!',
       '>sample/firefox/t_test.js completed in',
       '\x1B[38;5;243mCompleted\x1B[0m sample/firefox',
-      'Testsuite: shutdown',
       'Elapsed:',
+      'Testsuite: shutdown',
       '\x1B[38;5;99mStarted\x1B[0m sample/chrome',
       '!Running: sample/chrome/t_test.js, path: tests/t_test.js',
       '\x1B[32mOk:\x1B[0m Webdriver Works!',
@@ -23,8 +23,8 @@ export async function test() {
       '\x1B[38;5;243mCompleted\x1B[0m sample/chrome',
       '\x1B[102mSuccess!\x1B[0m Total: 2',
       '\x1B[38;5;243mCompleted\x1B[0m sample/',
-      'Testsuite: shutdown',
       'Elapsed:',
+      'Testsuite: shutdown',
     ],
     'stdout',
   );

package/tests/e2e/t_wd_mixed_firefox.js

@@ -19,13 +19,13 @@ export async function test() {
       '\x1B[32mOk:\x1B[0m Webdriver Works!',
       '>sample/ui/firefox/t_test.js completed in',
       '\x1B[38;5;243mCompleted\x1B[0m sample/ui/firefox',
-      'Testsuite: shutdown',
       'Elapsed:',
+      'Testsuite: shutdown',
       '\x1B[38;5;243mCompleted\x1B[0m sample/ui',
       '\x1B[102mSuccess!\x1B[0m Total: 2',
       '\x1B[38;5;243mCompleted\x1B[0m sample/',
-      'Testsuite: shutdown',
       'Elapsed:',
+      'Testsuite: shutdown',
     ],
     'stdout',
   );

package/tests/e2e/t_wd_mixed_firefox_chrome.js

@@ -19,8 +19,8 @@ export async function test() {
       '\x1B[32mOk:\x1B[0m Webdriver Works!',
       '>sample/ui/firefox/t_test.js completed in',
       '\x1B[38;5;243mCompleted\x1B[0m sample/ui/firefox',
-      'Testsuite: shutdown',
       'Elapsed:',
+      'Testsuite: shutdown',
       '\x1B[38;5;99mStarted\x1B[0m sample/ui/chrome',
       '!Running: sample/ui/chrome/t_test.js, path: tests/ui/t_test.js',
       '\x1B[32mOk:\x1B[0m Webdriver Works!',
@@ -29,8 +29,8 @@ export async function test() {
       '\x1B[38;5;243mCompleted\x1B[0m sample/ui',
       '\x1B[102mSuccess!\x1B[0m Total: 3',
       '\x1B[38;5;243mCompleted\x1B[0m sample/',
-      'Testsuite: shutdown',
       'Elapsed:',
+      'Testsuite: shutdown',
     ],
     'stdout',
   );

package/tests/series/build/t_pattern_filtering.js

@@ -0,0 +1,175 @@
+import { is, MockSeries } from '../test.js';
+
+export async function test() {
+  // Test that buildSubtests only processes subfolders that match patterns
+  // This test tracks which directories are actually accessed to verify the optimization
+
+  const accessedDirs = [];
+
+  class TrackingMockSeries extends MockSeries {
+    loadTestMeta(folder) {
+      accessedDirs.push(folder);
+      return super.loadTestMeta(folder);
+    }
+
+    getTestFileList(folder) {
+      accessedDirs.push(folder);
+      return super.getTestFileList(folder);
+    }
+  }
+
+  const ts = {
+    'tests': {
+      meta: {
+        folders: ['unit', 'integration', 'e2e'],
+      },
+    },
+    'tests/unit': {
+      meta: {
+        folders: ['base', 'core'],
+      },
+    },
+    'tests/unit/base': {
+      files: ['t_test1.js'],
+    },
+    'tests/unit/base/t_test1.js': {
+      test() {},
+    },
+    'tests/unit/core': {
+      files: ['t_test2.js'],
+    },
+    'tests/unit/core/t_test2.js': {
+      test() {},
+    },
+    'tests/integration': {
+      files: ['t_integration.js'],
+    },
+    'tests/integration/t_integration.js': {
+      test() {},
+    },
+    'tests/e2e': {
+      files: ['t_e2e.js'],
+    },
+    'tests/e2e/t_e2e.js': {
+      test() {},
+    },
+  };
+
+  const series = new TrackingMockSeries([], { ts });
+
+  // Test 1: When targeting a specific test, only relevant folders should be processed
+  accessedDirs.length = 0; // Clear the array
+
+  const tests = await series.build({
+    patterns: [
+      {
+        path: 'tests/unit/base/t_test1.js',
+        webdriver: '',
+      },
+    ],
+    folder: 'tests',
+    virtual_folder: 'mac',
+  });
+  series.shutdown();
+
+  // Should only build the unit folder and its relevant subfolders
+  // Should NOT build integration or e2e folders
+  const testNames = getAllTestNames(tests);
+
+  // Should include the targeted test and its path
+  is(
+    testNames.includes('mac/unit/base/t_test1.js'),
+    true,
+    'Should include the targeted test',
+  );
+
+  // Should NOT include tests from unrelated folders
+  is(
+    testNames.includes('mac/integration/t_integration.js'),
+    false,
+    'Should not include integration tests when targeting unit test',
+  );
+
+  is(
+    testNames.includes('mac/e2e/t_e2e.js'),
+    false,
+    'Should not include e2e tests when targeting unit test',
+  );
+
+  // Check directory access optimization - this will fail with commented optimization
+  is(
+    accessedDirs.includes('tests/integration'),
+    false,
+    'Should not access integration directory when targeting unit test',
+  );
+
+  is(
+    accessedDirs.includes('tests/e2e'),
+    false,
+    'Should not access e2e directory when targeting unit test',
+  );
+
+  // Test 2: When no patterns specified, all folders should be processed
+  accessedDirs.length = 0; // Clear the array
+
+  const allTests = await series.build({
+    patterns: [],
+    folder: 'tests',
+    virtual_folder: 'mac',
+  });
+
+  const allTestNames = getAllTestNames(allTests);
+
+  // Should include all tests when no patterns specified
+  is(
+    allTestNames.includes('mac/unit/base/t_test1.js'),
+    true,
+    'Should include unit test when no patterns',
+  );
+
+  is(
+    allTestNames.includes('mac/integration/t_integration.js'),
+    true,
+    'Should include integration test when no patterns',
+  );
+
+  is(
+    allTestNames.includes('mac/e2e/t_e2e.js'),
+    true,
+    'Should include e2e test when no patterns',
+  );
+
+  // When no patterns, all directories should be accessed
+  is(
+    accessedDirs.includes('tests/integration'),
+    true,
+    'Should access integration directory when no patterns specified',
+  );
+
+  is(
+    accessedDirs.includes('tests/e2e'),
+    true,
+    'Should access e2e directory when no patterns specified',
+  );
+}
+
+function getAllTestNames(tests) {
+  const names = [];
+
+  function collectNames(testList) {
+    for (const test of testList) {
+      if (test.subtests) {
+        collectNames(test.subtests);
+      } else if (
+        test.name &&
+        !test.name.includes('/init') &&
+        !test.name.includes('/uninit')
+      ) {
+        names.push(test.name);
+      }
+    }
+  }
+
+  collectNames(tests);
+  return names;
+}

package/tests/series/logging/t_verify.js

@@ -146,7 +146,7 @@ export async function test() {
   is(
     buffers,
     [
-      ['log', ['Testsuite: shutdown', got => got.startsWith('Elapsed:')]],
+      ['log', [got => got.startsWith('Elapsed:')]],
       [
         'mac/log',
         [

package/tests/series/meta.js

@@ -5,4 +5,5 @@ export var folders = [
   'run',
   'logging',
   'loader',
+  'servicer',
 ];

package/tests/series/perform/t_failure.js

@@ -21,6 +21,7 @@ export async function test() {
     '!Running: t_testo.js, path: t_testo.js',
     '>t_testo.js completed in',
     '\x1B[38;5;243mCompleted\x1B[0m tests/',
+    'Testsuite: shutdown',
   ];
   const expected_stderr = [
     '\x1B[31mFailed:\x1B[0m Failio',

package/tests/series/perform/t_failure_notest.js

@@ -16,6 +16,7 @@ export async function test() {
       '!Running: t_testo.js, path: t_testo.js',
       '>t_testo.js completed in',
       '\x1B[38;5;243mCompleted\x1B[0m tests/',
+      'Testsuite: shutdown',
     ],
     [
       '\x1B[31mFailed:\x1B[0m Neighter failure nor success in t_testo.js',

package/tests/series/perform/t_intermittent.js

@@ -26,6 +26,7 @@ export async function test() {
     '>t_testo.js has 1 warnings(s)',
     '>t_testo.js completed in',
     '\x1B[38;5;243mCompleted\x1B[0m tests/',
+    'Testsuite: shutdown',
   ];
   let expected_stderr = [];
 
@@ -77,6 +78,7 @@ export async function test() {
     '>t_testo_2.js has 3 warnings(s)',
     '>t_testo_2.js completed in',
     '\x1B[38;5;243mCompleted\x1B[0m tests/',
+    'Testsuite: shutdown',
   ];
   expected_stderr = [];
 

package/tests/series/perform/t_intermittent_global.js

@@ -71,6 +71,7 @@ export async function test() {
       '\x1B[38;5;243mCompleted\x1B[0m unit/core',
       '\x1B[38;5;243mCompleted\x1B[0m unit',
       '\x1B[38;5;243mCompleted\x1B[0m tests/',
+      'Testsuite: shutdown',
     ],
     [],
     'global intermittents',

package/tests/series/perform/t_missing_perma.js

@@ -33,6 +33,7 @@ export async function test() {
       '!Running: t_testo.js, path: t_testo.js',
       '>t_testo.js completed in',
       '\x1B[38;5;243mCompleted\x1B[0m tests/',
+      'Testsuite: shutdown',
     ],
     [
       '\x1B[31mFailed:\x1B[0m Server busy',
@@ -79,6 +80,7 @@ export async function test() {
       '>t_testo.js has 1 warnings(s)',
       '>t_testo.js completed in',
       '\x1B[38;5;243mCompleted\x1B[0m tests/',
+      'Testsuite: shutdown',
     ],
     [],
     'no perma but intermittent',

package/tests/series/perform/t_nested.js

@@ -50,6 +50,7 @@ export async function test() {
       '\x1B[38;5;243mCompleted\x1B[0m unit/core',
       '\x1B[38;5;243mCompleted\x1B[0m unit',
       '\x1B[38;5;243mCompleted\x1B[0m tests/',
+      'Testsuite: shutdown',
     ],
     [],
     'nested',

package/tests/series/perform/t_perma.js

@@ -36,6 +36,7 @@ export async function test() {
       '>t_testo.js has 1 warnings(s)',
       '>t_testo.js completed in',
       '\x1B[38;5;243mCompleted\x1B[0m tests/',
+      'Testsuite: shutdown',
     ],
     [],
     'perma',

package/tests/series/perform/t_success.js

@@ -18,6 +18,7 @@ export async function test() {
       '\x1B[32mOk:\x1B[0m Successio!',
       '>t_testo.js completed in',
       '\x1B[38;5;243mCompleted\x1B[0m tests/',
+      'Testsuite: shutdown',
     ],
     [],
     'success',
@@ -53,6 +54,7 @@ export async function test() {
       '\x1B[32mOk:\x1B[0m Successio!',
       '>t_testo.js completed in',
       '\x1B[38;5;243mCompleted\x1B[0m tests/',
+      'Testsuite: shutdown',
     ],
     [],
     'success #2',

package/tests/series/run/t_debunk_failure.js

@@ -31,9 +31,9 @@ export async function test() {
     '\x1B[41m\x1B[37mFailed!\x1B[0m Passed: 0. Failed: 1',
     '\x1B[38;5;243mCompleted\x1B[0m mac/',
     'Logs are written to',
-    'Testsuite: shutdown',
     'Elapsed:',
     'Logs are written to',
+    'Testsuite: shutdown',
   ];
 
   const expected_stderr = [

package/tests/series/run/t_debunk_success.js

@@ -40,9 +40,9 @@ export async function test() {
     ...expected_out_for_success,
     ...expected_out_for_success,
 
-    'Testsuite: shutdown',
     'Elapsed:',
     'Logs are written to',
+    'Testsuite: shutdown',
   ];
 
   const expected_stderr = [];

package/tests/series/run/t_nested.js

@@ -55,9 +55,9 @@ export async function test() {
       '\x1B[102mSuccess!\x1B[0m Total: 2',
       '\x1B[38;5;243mCompleted\x1B[0m mac/',
       'Logs are written to',
-      'Testsuite: shutdown',
       'Elapsed:',
       'Logs are written to',
+      'Testsuite: shutdown',
     ],
     [],
     'nested',

package/tests/series/run/t_verify.js

@@ -66,9 +66,9 @@ export async function test() {
     '\x1B[41m\x1B[37mFailed!\x1B[0m Passed: 0. Failed: 1',
     '\x1B[38;5;243mCompleted\x1B[0m mac/',
     'Logs are written to',
-    'Testsuite: shutdown',
     'Elapsed:',
     'Logs are written to',
+    'Testsuite: shutdown',
   ];
 
   const expected_stderr = [

package/tests/series/run/t_verify_webdriver.js

@@ -84,9 +84,9 @@ export async function test() {
     '\x1B[102mSuccess!\x1B[0m Total: 1',
     '\x1B[38;5;243mCompleted\x1B[0m mac/',
     'Logs are written to',
-    'Testsuite: shutdown',
     'Elapsed:',
     'Logs are written to',
+    'Testsuite: shutdown',
   ];
 
   const expected_stderr = [

package/tests/series/servicer/t_servicer.js

@@ -0,0 +1,84 @@
+import { is_test_output, success } from '../../base/test.js';
+import { log } from '../../../logging/logging.js';
+import { MockSeries } from '../mock_series.js';
+
+// Mock servicer that logs to console for output validation
+class MockServicer {
+  constructor(type) {
+    this.type = type;
+  }
+
+  async start(service) {
+    log(`MockServicer:${this.type} starting ${service}`);
+    return { started: service, type: this.type };
+  }
+
+  async stop(service) {
+    log(`MockServicer:${this.type} stopping ${service}`);
+    return { stopped: service, type: this.type };
+  }
+
+  async shutdown() {
+    log(`MockServicer:${this.type} shutdown`);
+    return { shutdown: true, type: this.type };
+  }
+
+  async ontest() {
+    // Optional: log test notifications
+    return null;
+  }
+}
+
+// Extended MockSeries that uses our logging servicer
+class MockSeriesWithServicer extends MockSeries {
+  createServicer(type) {
+    return new MockServicer(type || 'default');
+  }
+}
+
+export async function test() {
+  const ts = {
+    'tests': {
+      meta: {
+        servicer: 'docker',
+        services: ['mysql', 'redis'],
+      },
+      files: ['t_example.js'],
+    },
+    'tests/t_example.js': {
+      test() {
+        success('Servicer test example works');
+      },
+    },
+  };
+
+  await is_test_output(
+    () => MockSeriesWithServicer.run([], { ts }),
+    [
+      'Settings: no temporary storage dir',
+      'Settings: logging into /tmp',
+      'Settings: chrome webdrivers',
+      '\x1B[38;5;99mStarted\x1B[0m mac/',
+      '!Running: mac/init, path: tests/meta.js',
+      'MockServicer:docker starting mysql',
+      'MockServicer:docker starting redis',
+      '>mac/init completed in',
+      '!Running: mac/t_example.js, path: tests/t_example.js',
+      '\x1B[32mOk:\x1B[0m Servicer test example works',
+      '>mac/t_example.js completed in',
+      '!Running: mac/uninit, path: tests/meta.js',
+      'MockServicer:docker stopping redis',
+      'MockServicer:docker stopping mysql',
+      'MockServicer:docker shutdown',
+      '>mac/uninit completed in',
+      '\x1B[102mSuccess!\x1B[0m Total: 1',
+      '\x1B[38;5;243mCompleted\x1B[0m mac/',
+      'Logs are written to',
+      'Elapsed:',
+      'Logs are written to',
+      'Testsuite: shutdown'
+    ],
+    [],
+    'servicer lifecycle',
+  );
+}