@appium/base-driver 10.6.0 → 10.7.0

package/lib/protocol/protocol.ts

@@ -15,7 +15,14 @@ import {isW3cCaps} from '../helpers/capabilities';
 import {log} from '../basedriver/logger';
 import {omitKeys} from '../utils';
 import {generateDriverLogPrefix} from '../basedriver/helpers';
-import type {Core, AppiumLogger, PayloadParams, MethodMap, Driver, DriverMethodDef} from '@appium/types';
+import type {
+  Core,
+  AppiumLogger,
+  PayloadParams,
+  MethodMap,
+  Driver,
+  DriverMethodDef,
+} from '@appium/types';
 import type {BaseDriver} from '../basedriver/driver';
 import type {Request, Response, Application} from 'express';
 import type {MultidimensionalReadonlyArray} from 'type-fest';
@@ -54,10 +61,10 @@ export function getSessionId(driver: Core<any>, req: Request): string | undefine
     const sessionId = req.params.sessionId[0];
     getLogger(driver, sessionId).warn(
       `Received malformed sessionId as array from the route: ${req.originalUrl}. ` +
-      `This indicates the route definition issue. The route should start with '/session/:sessionId' (named parameter) ` +
-      `instead of '/session/*sessionId' (wildcard). ` +
-      `Using the first element as session id: ${sessionId}. ` +
-      `Please fix the route definition to prevent this error.`
+        `This indicates the route definition issue. The route should start with '/session/:sessionId' (named parameter) ` +
+        `instead of '/session/*sessionId' (wildcard). ` +
+        `Using the first element as session id: ${sessionId}. ` +
+        `Please fix the route definition to prevent this error.`,
     );
     // This is to not log the message multiple times.
     req.params.sessionId = sessionId;
@@ -83,7 +90,7 @@ export function isSessionCommand(command: string): boolean {
 export function checkParams(
   paramSpec: PayloadParams,
   args: Record<string, any>,
-  protocol?: keyof typeof PROTOCOLS
+  protocol?: keyof typeof PROTOCOLS,
 ): Record<string, any> {
   let requiredParams: string[][] = [];
   let optionalParams: string[] = [];
@@ -95,8 +102,7 @@ export function checkParams(
     requiredParams = structuredClone(
       (hasMultipleRequiredParamSets(paramSpec.required)
         ? paramSpec.required
-        : [paramSpec.required]
-      ) as string[][]
+        : [paramSpec.required]) as string[][],
     );
   }
   // optional parameters are just an array
@@ -126,7 +132,10 @@ export function checkParams(
 
   if (util.isEmpty(requiredParams)) {
     // if we don't have any required parameters, then just filter out unknown ones
-    return pickKnownParams(args, actualParamNames.filter((name) => !optionalParams.includes(name)));
+    return pickKnownParams(
+      args,
+      actualParamNames.filter((name) => !optionalParams.includes(name)),
+    );
   }
 
   // go through the required parameters and check against our arguments
@@ -135,25 +144,30 @@ export function checkParams(
     if (!Array.isArray(requiredParamsSet)) {
       throw new Error(
         `The required parameter set item ${JSON.stringify(requiredParamsSet)} ` +
-        `in ${JSON.stringify(paramSpec)} is not an array. ` +
-        `This is a bug in the method map definition.`
+          `in ${JSON.stringify(paramSpec)} is not an array. ` +
+          `This is a bug in the method map definition.`,
       );
     }
     if (requiredParamsSet.every((name) => actualParamNames.includes(name))) {
       return pickKnownParams(
         args,
-        actualParamNames.filter((name) => !requiredParamsSet.includes(name) && !optionalParams.includes(name))
+        actualParamNames.filter(
+          (name) => !requiredParamsSet.includes(name) && !optionalParams.includes(name),
+        ),
       );
     }
     if (!util.isEmpty(requiredParamsSet) && util.isEmpty(matchedReqParamSet)) {
       matchedReqParamSet = requiredParamsSet;
     }
   }
-  throw new BadParametersError({
-    ...paramSpec,
-    required: matchedReqParamSet,
-    optional: optionalParams,
-  }, actualParamNames);
+  throw new BadParametersError(
+    {
+      ...paramSpec,
+      required: matchedReqParamSet,
+      optional: optionalParams,
+    },
+    actualParamNames,
+  );
 }
 
 /**
@@ -162,7 +176,11 @@ export function checkParams(
  * @param jsonObj - Parsed JSON request body
  * @param payloadParams - Route payload definition (required/optional/makeArgs)
  */
-export function makeArgs(requestParams: PayloadParams, jsonObj: any, payloadParams: PayloadParams): any[] {
+export function makeArgs(
+  requestParams: Record<string, string | string[] | undefined>,
+  jsonObj: any,
+  payloadParams: PayloadParams,
+): any[] {
   // We want to pass the "url" parameters to the commands in reverse order
   // since the command will sometimes want to ignore, say, the sessionId.
   // This has the effect of putting sessionId last, which means in JS we can
@@ -224,14 +242,14 @@ export function validateExecuteMethodParams(params: any[], paramSpec?: PayloadPa
   if (!params || !Array.isArray(params) || params.length > 1) {
     throw new errors.InvalidArgumentError(
       `Did not get correct format of arguments for execute method. Expected zero or one ` +
-        `arguments to execute script and instead received: ${JSON.stringify(params)}`
+        `arguments to execute script and instead received: ${JSON.stringify(params)}`,
     );
   }
   const args: Record<string, any> = params[0] ?? {};
   if (!util.isPlainObject(args)) {
     throw new errors.InvalidArgumentError(
       `Did not receive an appropriate execute method parameters object. It needs to be ` +
-        `deserializable as a plain JS object`
+        `deserializable as a plain JS object`,
     );
   }
   const specToUse = {
@@ -268,14 +286,7 @@ export function routeConfiguringFunction(driver: Core<any>): RouteConfiguringFun
       for (const [method, spec] of Object.entries(methods)) {
         const isSessCommand = spec.command ? isSessionCommand(spec.command) : false;
         // set up the express route handler
-        buildHandler(
-          app,
-          method,
-          `${basePath}${path}`,
-          spec,
-          driver,
-          isSessCommand
-        );
+        buildHandler(app, method, `${basePath}${path}`, spec, driver, isSessCommand);
       }
     }
   };
@@ -309,10 +320,14 @@ export function driverShouldDoJwpProxy(driver: Core<any>, req: Request, command:
   return true;
 }
 
-function extractProtocol(driver: Core<any>, sessionId: string | null = null): keyof typeof PROTOCOLS {
-  const dstDriver = typeof driver.driverForSession === 'function' && sessionId
-    ? driver.driverForSession(sessionId)
-    : driver;
+function extractProtocol(
+  driver: Core<any>,
+  sessionId: string | null = null,
+): keyof typeof PROTOCOLS {
+  const dstDriver =
+    typeof driver.driverForSession === 'function' && sessionId
+      ? driver.driverForSession(sessionId)
+      : driver;
   if (dstDriver === driver) {
     // Shortcircuit if the driver instance is not an umbrella driver
     // or it is Fake driver instance, where `driver.driverForSession`
@@ -327,7 +342,7 @@ function extractProtocol(driver: Core<any>, sessionId: string | null = null): ke
 function getLogger(driver: Core<any>, sessionId: string | null = null): AppiumLogger {
   const dstDriver =
     sessionId && typeof driver.driverForSession === 'function'
-      ? driver.driverForSession(sessionId) ?? driver
+      ? (driver.driverForSession(sessionId) ?? driver)
       : driver;
   if (typeof dstDriver.log?.info === 'function') {
     return dstDriver.log;
@@ -337,14 +352,15 @@ function getLogger(driver: Core<any>, sessionId: string | null = null): AppiumLo
   return logger.getLogger(logPrefix);
 }
 
-function wrapParams<T>(paramSets, jsonObj: T): T | Record<string, T> {
+function wrapParams<T>(paramSets: PayloadParams, jsonObj: T): T | Record<string, T> {
   /* There are commands like performTouch which take a single parameter (primitive type or array).
    * Some drivers choose to pass this parameter as a value (eg. [action1, action2...]) while others to
    * wrap it within an object(eg' {gesture:  [action1, action2...]}), which makes it hard to validate.
    * The wrap option in the spec enforce wrapping before validation, so that all params are wrapped at
    * the time they are validated and later passed to the commands.
    */
-  return (Array.isArray(jsonObj) || typeof jsonObj !== 'object' || jsonObj === null) && paramSets.wrap
+  return (Array.isArray(jsonObj) || typeof jsonObj !== 'object' || jsonObj === null) &&
+    paramSets.wrap
     ? {[paramSets.wrap]: jsonObj}
     : jsonObj;
 }
@@ -353,14 +369,15 @@ function unwrapParams<T>(paramSets: PayloadParams, jsonObj: T): T | Record<strin
   /* There are commands like setNetworkConnection which send parameters wrapped inside a key such as
    * "parameters". This function unwraps them (eg. {"parameters": {"type": 1}} becomes {"type": 1}).
    */
-  return typeof jsonObj === 'object' && jsonObj !== null && paramSets.unwrap && jsonObj[paramSets.unwrap]
-    ? jsonObj[paramSets.unwrap]
-    : jsonObj;
+  const unwrapped =
+    typeof jsonObj === 'object' && jsonObj !== null && paramSets.unwrap
+      ? (jsonObj as Record<string, T>)[paramSets.unwrap]
+      : undefined;
+  return unwrapped !== undefined ? unwrapped : jsonObj;
 }
 
-
 function hasMultipleRequiredParamSets(
-  required: ReadonlyArray<string> | MultidimensionalReadonlyArray<string, 2> | undefined
+  required: ReadonlyArray<string> | MultidimensionalReadonlyArray<string, 2> | undefined,
 ): required is MultidimensionalReadonlyArray<string, 2> {
   return Boolean(required && Array.isArray(required?.[0]));
 }
@@ -379,7 +396,7 @@ function buildHandler(
   path: string,
   spec: DriverMethodDef<Driver>,
   driver: Core<any>,
-  isSessCmd: boolean
+  isSessCmd: boolean,
 ): void {
   const asyncHandler = async (req: Request, res: Response) => {
     let jsonObj = req.body;
@@ -396,7 +413,7 @@ function buildHandler(
         getLogger(driver, sessionId).warn(
           `The ${method} ${path} endpoint has been deprecated and will be removed in a future ` +
             `version of Appium or your driver/plugin. Please use a different endpoint or contact the ` +
-            `driver/plugin author to add explicit support for the endpoint before it is removed`
+            `driver/plugin author to add explicit support for the endpoint before it is removed`,
         );
       }
 
@@ -415,9 +432,15 @@ function buildHandler(
       // commands and generally would not want that command to be proxied instead of handled by the
       // plugin)
       let didPluginOverrideProxy = false;
-      if (isSessCmd && !spec.neverProxy && spec.command && driverShouldDoJwpProxy(driver, req, spec.command)) {
+      if (
+        isSessCmd &&
+        !spec.neverProxy &&
+        spec.command &&
+        driverShouldDoJwpProxy(driver, req, spec.command)
+      ) {
         if (
-          !('pluginsToHandleCmd' in driver) || typeof driver.pluginsToHandleCmd !== 'function' ||
+          !('pluginsToHandleCmd' in driver) ||
+          typeof driver.pluginsToHandleCmd !== 'function' ||
           driver.pluginsToHandleCmd(spec.command, sessionId).length === 0
         ) {
           await doJwpProxy(driver as BaseDriver<any>, req, res);
@@ -426,7 +449,7 @@ function buildHandler(
         getLogger(driver, sessionId).debug(
           `Would have proxied ` +
             `command directly, but a plugin exists which might require its value, so will let ` +
-            `its value be collected internally and made part of plugin chain`
+            `its value be collected internally and made part of plugin chain`,
         );
         didPluginOverrideProxy = true;
       }
@@ -451,7 +474,7 @@ function buildHandler(
         // try to determine protocol by session creation args, so we can throw a
         // properly formatted error if arguments validation fails
         currentProtocol = determineProtocol(
-          makeArgs(req.params, jsonObj, spec.payloadParams || {})
+          makeArgs(req.params, jsonObj, spec.payloadParams || {}),
         );
       }
 
@@ -465,15 +488,21 @@ function buildHandler(
       const args = makeArgs(req.params, jsonObj, spec.payloadParams || {});
       let driverRes: any;
       // validate command args according to MJSONWP
-      if (validators[spec.command]) {
-        validators[spec.command](...args);
+      const validator = (
+        validators as Record<string, ((...validatorArgs: any[]) => void) | undefined>
+      )[spec.command];
+      if (validator) {
+        validator(...args);
       }
 
       // run the driver command wrapped inside the argument validators
       getLogger(driver, sessionId).debug(
         `Calling %s.%s() with args: %s`,
-        driver.constructor.name, spec.command,
-        logger.markSensitive(util.truncateString(JSON.stringify(args), {length: MAX_LOG_BODY_LENGTH}))
+        driver.constructor.name,
+        spec.command,
+        logger.markSensitive(
+          util.truncateString(JSON.stringify(args), {length: MAX_LOG_BODY_LENGTH}),
+        ),
       );
 
       if (didPluginOverrideProxy) {
@@ -491,7 +520,8 @@ function buildHandler(
       // If `executeCommand` was overridden and the method returns an object
       // with a protocol and value/error property, re-assign the protocol
       if (util.isPlainObject(driverRes) && Object.hasOwn(driverRes, 'protocol')) {
-        currentProtocol = (driverRes as {protocol?: keyof typeof PROTOCOLS}).protocol || currentProtocol;
+        currentProtocol =
+          (driverRes as {protocol?: keyof typeof PROTOCOLS}).protocol || currentProtocol;
         if (driverRes.error) {
           throw driverRes.error;
         }
@@ -502,7 +532,7 @@ function buildHandler(
       if (spec.command === CREATE_SESSION_COMMAND) {
         newSessionId = driverRes[0];
         getLogger(driver, newSessionId).debug(
-          `Cached the protocol value '${currentProtocol}' for the new session ${newSessionId}`
+          `Cached the protocol value '${currentProtocol}' for the new session ${newSessionId}`,
         );
         if (currentProtocol === PROTOCOLS.MJSONWP) {
           driverRes = driverRes[1];
@@ -520,7 +550,7 @@ function buildHandler(
         getLogger(driver, sessionId).debug(
           `Received response: ${util.truncateString(JSON.stringify(driverRes), {
             length: MAX_LOG_BODY_LENGTH,
-          })}`
+          })}`,
         );
         getLogger(driver, sessionId).debug('But deleting session, so not returning');
         driverRes = null;
@@ -538,7 +568,7 @@ function buildHandler(
           throw errorFromW3CJsonCode(
             driverRes.value.error,
             driverRes.value.message,
-            driverRes.value.stacktrace
+            driverRes.value.stacktrace,
           );
         }
       }
@@ -546,38 +576,48 @@ function buildHandler(
       httpResBody.value = driverRes;
       getLogger(driver, sessionId || newSessionId).debug(
         `Responding ` +
-          `to client with driver.${spec.command}() result: ${util.truncateString(JSON.stringify(driverRes), {
-            length: MAX_LOG_BODY_LENGTH,
-          })}`
+          `to client with driver.${spec.command}() result: ${util.truncateString(
+            JSON.stringify(driverRes),
+            {
+              length: MAX_LOG_BODY_LENGTH,
+            },
+          )}`,
       );
     } catch (err) {
       // if anything goes wrong, figure out what our response should be
       // based on the type of error that we encountered
-      let actualErr;
-      if (err instanceof Error || (Object.hasOwn(err, 'stack') && Object.hasOwn(err, 'message'))) {
+      let actualErr: Error;
+      if (err instanceof Error) {
         actualErr = err;
+      } else if (
+        typeof err === 'object' &&
+        err !== null &&
+        Object.hasOwn(err, 'stack') &&
+        Object.hasOwn(err, 'message')
+      ) {
+        actualErr = err as Error;
       } else {
         getLogger(driver, sessionId || newSessionId).warn(
           'The thrown error object does not seem to be a valid instance of the Error class. This ' +
-            'might be a genuine bug of a driver or a plugin.'
+            'might be a genuine bug of a driver or a plugin.',
         );
         actualErr = new Error(`${err ?? 'unknown'}`);
       }
 
-      currentProtocol =
-        currentProtocol || extractProtocol(driver, sessionId || newSessionId);
+      currentProtocol = currentProtocol || extractProtocol(driver, sessionId || newSessionId);
 
-      let errMsg = err.stacktrace || err.stack;
-      if (!errMsg.includes(err.message)) {
+      const stacktrace = (err as {stacktrace?: string}).stacktrace;
+      let errMsg = stacktrace || actualErr.stack || '';
+      if (!errMsg.includes(actualErr.message)) {
         // if the message has more information, add it. but often the message
         // is the first part of the stack trace
-        errMsg = `${err.message}${errMsg ? '\n' + errMsg : ''}`;
+        errMsg = `${actualErr.message}${errMsg ? '\n' + errMsg : ''}`;
       }
       if (isErrorType(err, errors.ProxyRequestError)) {
         actualErr = err.getActualError();
       } else {
         getLogger(driver, sessionId || newSessionId).debug(
-          `Encountered internal error running command: ${errMsg}`
+          `Encountered internal error running command: ${errMsg}`,
         );
       }
 
@@ -586,7 +626,8 @@ function buildHandler(
 
     // decode the response, which is either a string or json
     if (typeof httpResBody === 'string') {
-      res.status(httpStatus)
+      res
+        .status(httpStatus)
         .setHeader('content-type', 'application/json; charset=utf-8')
         .send(httpResBody);
     } else {
@@ -597,16 +638,17 @@ function buildHandler(
     }
   };
   // add the method to the app
-  app[method.toLowerCase()](path, (req, res) => {
+  const registerRoute = (
+    app as Application & Record<string, (routePath: string, ...handlers: any[]) => void>
+  )[method.toLowerCase()].bind(app);
+  registerRoute(path, (req: Request, res: Response) => {
     void asyncHandler(req, res);
   });
 }
 
 async function doJwpProxy(driver: BaseDriver<any>, req: Request, res: Response): Promise<void> {
   const sessionId = getSessionId(driver, req) as string;
-  getLogger(driver, sessionId).info(
-    'Driver proxy active, passing request on via HTTP proxy'
-  );
+  getLogger(driver, sessionId).info('Driver proxy active, passing request on via HTTP proxy');
 
   // check that the inner driver has a proxy function
   if (!driver.canProxy(sessionId)) {
@@ -617,8 +659,10 @@ async function doJwpProxy(driver: BaseDriver<any>, req: Request, res: Response):
   } catch (err) {
     if (isErrorType(err, errors.ProxyRequestError)) {
       throw err;
-    } else {
+    }
+    if (err instanceof Error) {
       throw new Error(`Could not proxy. Proxy error: ${err.message}`, {cause: err});
     }
+    throw new Error(`Could not proxy. Proxy error: ${String(err)}`, {cause: err});
   }
 }

package/lib/protocol/routes.ts

@@ -14,7 +14,6 @@ const COMMAND_NAMES_CACHE = new LRUCache<string, string>({
  * `optional`.
  */
 export const METHOD_MAP = {
-
   // #region W3C WebDriver
   // https://www.w3.org/TR/webdriver2/
   '/session': {
@@ -244,8 +243,8 @@ export const METHOD_MAP = {
           'shrinkToFit',
           'pageRanges',
         ],
-      }
-    }
+      },
+    },
   },
   // #endregion
 
@@ -274,7 +273,7 @@ export const METHOD_MAP = {
     GET: {command: 'getOrientation'},
     POST: {
       command: 'setOrientation',
-      payloadParams: {required: ['orientation']}
+      payloadParams: {required: ['orientation']},
     },
   },
   '/session/:sessionId/location': {
@@ -318,7 +317,7 @@ export const METHOD_MAP = {
     GET: {command: 'getAppiumSessions'},
   },
   '/session/:sessionId/appium/capabilities': {
-    GET: {command: 'getAppiumSessionCapabilities'}
+    GET: {command: 'getAppiumSessionCapabilities'},
   },
   '/session/:sessionId/appium/settings': {
     POST: {command: 'updateSettings', payloadParams: {required: ['settings']}},
@@ -592,7 +591,7 @@ export const ALL_COMMANDS = Object.values(METHOD_MAP)
 export function routeToCommandName(
   endpoint: string,
   method?: HTTPMethod,
-  basePath?: string
+  basePath?: string,
 ): string | undefined {
   const resolvedBasePath = basePath ?? DEFAULT_BASE_PATH;
   let normalizedEndpoint = resolvedBasePath
@@ -624,9 +623,10 @@ export function routeToCommandName(
     const routeMatcher = match(routePath);
     if (possiblePathnames.some((pp) => routeMatcher(pp))) {
       const spec = routeSpec as Record<string, DriverMethodDef<Driver>>;
-      const commandForAnyMethod = () =>
-        Object.keys(spec).map((key) => spec[key]?.command)[0];
-      const commandName = normalizedMethod ? spec[normalizedMethod]?.command : commandForAnyMethod();
+      const commandForAnyMethod = () => Object.keys(spec).map((key) => spec[key]?.command)[0];
+      const commandName = normalizedMethod
+        ? spec[normalizedMethod]?.command
+        : commandForAnyMethod();
       if (commandName) {
         COMMAND_NAMES_CACHE.set(cacheKey, commandName);
         return commandName;

package/lib/test-pages/env.ts

@@ -0,0 +1,9 @@
+/** Environment variable that opts into deprecated built-in test pages on the Appium server. */
+export const LEGACY_TEST_PAGES_ENV = 'APPIUM_ENABLE_LEGACY_TEST_PAGES';
+
+const TRUTHY = new Set(['1', 'true', 'yes']);
+
+/** @returns Whether built-in legacy test pages should be mounted on the Appium server. */
+export function isLegacyTestPagesEnabled(): boolean {
+  return TRUTHY.has(String(process.env[LEGACY_TEST_PAGES_ENV] ?? '').toLowerCase());
+}

package/lib/{express/static.ts → test-pages/handlers.ts}

@@ -1,11 +1,10 @@
 import path from 'node:path';
-import {log} from './logger';
+import {log} from '../express/logger';
 import {fs} from '@appium/support';
 import {sleep} from 'asyncbox';
 import type {Request, Response} from 'express';
-import {compileLodashTemplate} from '../utils';
-
-export const STATIC_DIR = resolveStaticDir();
+import {compileLodashTemplate} from './template';
+import {TEST_FIXTURES_DIR} from './static-dir';
 
 type TemplateParams = Record<string, unknown>;
 
@@ -32,15 +31,8 @@ export async function welcome(req: Request, res: Response): Promise<void> {
   res.send(template(params));
 }
 
-async function guineaPigTemplate(
-  req: Request,
-  res: Response,
-  page: string
-): Promise<void> {
-  const delay = parseInt(
-    String(req.params.delay ?? (req.query?.delay ?? 0)),
-    10
-  );
+async function guineaPigTemplate(req: Request, res: Response, page: string): Promise<void> {
+  const delay = parseInt(String(req.params.delay ?? req.query?.delay ?? 0), 10);
   const throwError = String(req.params.throwError ?? req.query?.throwError ?? '');
   const params: TemplateParams = {
     throwError,
@@ -67,19 +59,7 @@ async function guineaPigTemplate(
   res.send(template(params));
 }
 
-async function getTemplate(
-  templateName: string
-): Promise<(params: TemplateParams) => string> {
-  const content = await fs.readFile(path.resolve(STATIC_DIR, 'test', templateName));
+async function getTemplate(templateName: string): Promise<(params: TemplateParams) => string> {
+  const content = await fs.readFile(path.resolve(TEST_FIXTURES_DIR, 'test', templateName));
   return compileLodashTemplate(content.toString());
 }
-
-function resolveStaticDir(): string {
-  const fromDir = __dirname;
-  const parts = path.resolve(fromDir).split(path.sep);
-  const baseDriverIndex = parts.indexOf('base-driver');
-  if (baseDriverIndex < 0) {
-    throw new Error(`Could not find the module root folder in the path: ${fromDir}`);
-  }
-  return path.join(parts.slice(0, baseDriverIndex + 1).join(path.sep), 'static');
-}

package/lib/test-pages/index.ts

@@ -0,0 +1,34 @@
+import path from 'node:path';
+import express from 'express';
+import type {Express} from 'express';
+import favicon from 'serve-favicon';
+import {guineaPig, guineaPigScrollable, guineaPigAppBanner, welcome} from './handlers';
+import {produceError, produceCrash} from './crash';
+import {TEST_FIXTURES_DIR} from './static-dir';
+
+export interface RegisterTestPagesOpts {
+  basePath: string;
+}
+
+/**
+ * Mount deprecated built-in test pages and crash routes on an Express app.
+ *
+ * @deprecated Built-in test pages on the Appium server are deprecated and will be removed in
+ * Appium 4. Driver CI should hard-copy needed fixtures and run a local test HTTP server.
+ * @internal
+ */
+export function registerTestPages(app: Express, {basePath}: RegisterTestPagesOpts): void {
+  app.use(favicon(path.resolve(TEST_FIXTURES_DIR, 'favicon.ico')));
+  app.use(express.static(TEST_FIXTURES_DIR));
+
+  app.use(`${basePath}/produce_error`, produceError);
+  app.use(`${basePath}/crash`, produceCrash);
+
+  app.all('/welcome', welcome);
+  app.all('/test/guinea-pig', guineaPig);
+  app.all('/test/guinea-pig-scrollable', guineaPigScrollable);
+  app.all('/test/guinea-pig-app-banner', guineaPigAppBanner);
+}
+
+export {TEST_FIXTURES_DIR} from './static-dir';
+export {isLegacyTestPagesEnabled} from './env';

package/lib/test-pages/static-dir.ts

@@ -0,0 +1,19 @@
+import path from 'node:path';
+
+/**
+ * Absolute path to bundled legacy test fixture static files.
+ *
+ * @deprecated Removed in Appium 4. Test fixture files will live in the appium/test-fixtures
+ * repository. Do not depend on this path in driver CI — hard-copy needed files locally.
+ */
+export const TEST_FIXTURES_DIR = resolveTestFixturesDir();
+
+function resolveTestFixturesDir(): string {
+  const fromDir = __dirname;
+  const parts = path.resolve(fromDir).split(path.sep);
+  const baseDriverIndex = parts.indexOf('base-driver');
+  if (baseDriverIndex < 0) {
+    throw new Error(`Could not find the module root folder in the path: ${fromDir}`);
+  }
+  return path.join(parts.slice(0, baseDriverIndex + 1).join(path.sep), 'test-fixtures', 'static');
+}

package/lib/test-pages/template.ts

@@ -0,0 +1,17 @@
+/** Compile a lodash-style template string (`<%= expression %>`) into a render function. */
+export function compileLodashTemplate(
+  template: string,
+): (params: Record<string, unknown>) => string {
+  const parts: string[] = [];
+  let lastIndex = 0;
+  const re = /<%=\s*([\s\S]+?)\s*%>/g;
+  let match;
+  while ((match = re.exec(template)) !== null) {
+    parts.push(JSON.stringify(template.slice(lastIndex, match.index)));
+    parts.push(`String(${match[1]})`);
+    lastIndex = match.index + match[0].length;
+  }
+  parts.push(JSON.stringify(template.slice(lastIndex)));
+  const fn = new Function('obj', `with (obj) { return ${parts.join(' + ')}; }`);
+  return (params) => fn(params) as string;
+}

package/lib/utils.ts

@@ -48,7 +48,7 @@ export function omitKeys<T extends Record<string, unknown>>(obj: T, keys: readon
 /** Return a shallow copy of `obj` containing only listed keys. */
 export function pick<T extends Record<string, unknown>>(
   obj: T,
-  keys: readonly string[]
+  keys: readonly string[],
 ): Partial<T> {
   const keysToPick = new Set(keys);
   return Object.fromEntries(Object.entries(obj).filter(([k]) => keysToPick.has(k))) as Partial<T>;
@@ -57,29 +57,9 @@ export function pick<T extends Record<string, unknown>>(
 /** Return a shallow copy of `obj` whose entries pass `predicate`. */
 export function pickBy<T extends Record<string, unknown>>(
   obj: T,
-  predicate: (value: T[keyof T], key: keyof T) => boolean
+  predicate: (value: T[keyof T], key: keyof T) => boolean,
 ): Partial<T> {
   return Object.fromEntries(
-    Object.entries(obj).filter(([key, value]) =>
-      predicate(value as T[keyof T], key as keyof T)
-    )
+    Object.entries(obj).filter(([key, value]) => predicate(value as T[keyof T], key as keyof T)),
   ) as Partial<T>;
 }
-
-/** Compile a lodash-style template string (`<%= expression %>`) into a render function. */
-export function compileLodashTemplate(
-  template: string
-): (params: Record<string, unknown>) => string {
-  const parts: string[] = [];
-  let lastIndex = 0;
-  const re = /<%=\s*([\s\S]+?)\s*%>/g;
-  let match;
-  while ((match = re.exec(template)) !== null) {
-    parts.push(JSON.stringify(template.slice(lastIndex, match.index)));
-    parts.push(`String(${match[1]})`);
-    lastIndex = match.index + match[0].length;
-  }
-  parts.push(JSON.stringify(template.slice(lastIndex)));
-  const fn = new Function('obj', `with (obj) { return ${parts.join(' + ')}; }`);
-  return (params) => fn(params) as string;
-}