appium 2.0.0-beta.6 → 2.0.0-beta.60

package/lib/extension/plugin-config.js

@@ -0,0 +1,112 @@
+import _ from 'lodash';
+import {ExtensionConfig} from './extension-config';
+import log from '../logger';
+import {PLUGIN_TYPE} from '../constants';
+
+/**
+ * @extends {ExtensionConfig<PluginType>}
+ */
+export class PluginConfig extends ExtensionConfig {
+  /**
+   * A mapping of {@link Manifest} instances to {@link PluginConfig} instances.
+   *
+   * `Manifest` and {@link ExtensionConfig} have a one-to-many relationship; each `Manifest` should be associated with a `DriverConfig` and a `PluginConfig`; no more, no less.
+   *
+   * This variable tracks the `Manifest`-to-`PluginConfig` portion.
+   *
+   * @type {WeakMap<Manifest,PluginConfig>}
+   * @private
+   */
+  static _instances = new WeakMap();
+
+  /**
+   * Call {@link PluginConfig.create} instead.
+   *
+   * Just calls the superclass' constructor with the correct extension type
+   * @private
+   * @param {Manifest} manifest - IO object
+   */
+  constructor(manifest) {
+    super(PLUGIN_TYPE, manifest);
+  }
+
+  async validate() {
+    return await super._validate(this.manifest.getExtensionData(PLUGIN_TYPE));
+  }
+
+  /**
+   * Creates a new {@link PluginConfig} instance for a {@link Manifest} instance.
+   *
+   * @param {Manifest} manifest
+   * @throws If `manifest` already associated with a `PluginConfig`
+   * @returns {PluginConfig}
+   */
+  static create(manifest) {
+    const instance = new PluginConfig(manifest);
+    if (PluginConfig.getInstance(manifest)) {
+      throw new Error(
+        `Manifest with APPIUM_HOME ${manifest.appiumHome} already has a PluginConfig; use PluginConfig.getInstance() to retrieve it.`
+      );
+    }
+    PluginConfig._instances.set(manifest, instance);
+    return instance;
+  }
+
+  /**
+   * Returns a PluginConfig associated with a Manifest
+   * @param {Manifest} manifest
+   * @returns {PluginConfig|undefined}
+   */
+  static getInstance(manifest) {
+    return PluginConfig._instances.get(manifest);
+  }
+
+  /**
+   * @param {string} pluginName
+   * @param {import('appium/types').ExtManifest<PluginType>} pluginData
+   * @returns {string}
+   */
+  extensionDesc(pluginName, {version}) {
+    return `${pluginName}@${version}`;
+  }
+
+  /**
+   *
+   * @param {(keyof import('appium/types').ExtRecord<PluginType>)[]} activeNames
+   * @returns {void}
+   */
+  print(activeNames) {
+    const pluginNames = Object.keys(this.installedExtensions);
+
+    if (_.isEmpty(pluginNames)) {
+      log.info(
+        `No plugins have been installed. Use the "appium plugin" ` +
+          'command to install the one(s) you want to use.'
+      );
+      return;
+    }
+
+    log.info(`Available plugins:`);
+    for (const [pluginName, pluginData] of _.toPairs(this.installedExtensions)) {
+      const activeTxt = _.includes(activeNames, pluginName) ? ' (ACTIVE)' : '';
+      log.info(`  - ${this.extensionDesc(pluginName, pluginData)}${activeTxt}`);
+    }
+
+    if (_.isEmpty(activeNames)) {
+      log.info(
+        'No plugins activated. Use the --use-plugins flag with names of plugins to activate'
+      );
+    }
+  }
+}
+
+/**
+ * @typedef PluginConfigOptions
+ * @property {import('./extension-config').ExtensionLogFn} [logFn] - Optional logging function
+ */
+
+/**
+ * @typedef {import('@appium/types').PluginType} PluginType
+ * @typedef {import('appium/types').ExtMetadata<PluginType>} PluginMetadata
+ * @typedef {import('./manifest').Manifest} Manifest
+ */

package/lib/grid-register.js

@@ -1,53 +1,60 @@
 import axios from 'axios';
-import { fs } from 'appium-support';
+import {fs} from '@appium/support';
 import logger from './logger';
 import _ from 'lodash';
 
-
 const hubUri = (config) => {
   const protocol = config.hubProtocol || 'http';
   return `${protocol}://${config.hubHost}:${config.hubPort}`;
 };
 
-async function registerNode (configFile, addr, port, basePath) {
-  let data;
-  try {
-    data = await fs.readFile(configFile, 'utf-8');
-  } catch (err) {
-    logger.error(`Unable to load node configuration file to register with grid: ${err.message}`);
-    return;
+/**
+ * Registers a new node with a selenium grid
+ * @param {string|object} data - Path or object representing selenium grid node config file. If a `string`, all subsequent arguments are required!
+ * @param {string} [addr] - Bind to this address
+ * @param {number} [port] - Bind to this port
+ * @param {string} [basePath] - Base path for the grid
+ */
+async function registerNode(data, addr, port, basePath) {
+  let configFilePath;
+  if (_.isString(data)) {
+    configFilePath = data;
+    try {
+      data = await fs.readFile(data, 'utf-8');
+    } catch (err) {
+      logger.error(
+        `Unable to load node configuration file ${configFilePath} to register with grid: ${err.message}`
+      );
+      return;
+    }
+    try {
+      data = JSON.parse(data);
+    } catch (err) {
+      logger.errorAndThrow(
+        `Syntax error in node configuration file ${configFilePath}: ${err.message}`
+      );
+      return;
+    }
   }
 
-  // Check presence of data before posting  it to the selenium grid
-  if (!data) {
-    logger.error('No data found in the node configuration file to send to the grid');
-    return;
-  }
   postRequest(data, addr, port, basePath);
 }
 
-async function registerToGrid (postOptions, configHolder) {
+async function registerToGrid(postOptions, configHolder) {
   try {
     const {status} = await axios(postOptions);
     if (status !== 200) {
       throw new Error(`Request failed with code ${status}`);
     }
-    logger.debug(`Appium successfully registered with the the grid on ` +
-      hubUri(configHolder.configuration));
+    logger.debug(
+      `Appium successfully registered with the the grid on ` + hubUri(configHolder.configuration)
+    );
   } catch (err) {
     logger.error(`An attempt to register with the grid was unsuccessful: ${err.message}`);
   }
 }
 
-function postRequest (data, addr, port, basePath) {
-  // parse json to get hub host and port
-  let configHolder;
-  try {
-    configHolder = JSON.parse(data);
-  } catch (err) {
-    logger.errorAndThrow(`Syntax error in node configuration file: ${err.message}`);
-  }
-
+function postRequest(configHolder, addr, port, basePath) {
   // Move Selenium 3 configuration properties to configuration object
   if (!_.has(configHolder, 'configuration')) {
     let configuration = {};
@@ -65,7 +72,11 @@ function postRequest (data, addr, port, basePath) {
   // otherwise, we will take whatever the user setup
   // because we will always set localhost/127.0.0.1. this won't work if your
   // node and grid aren't in the same place
-  if (!configHolder.configuration.url || !configHolder.configuration.host || !configHolder.configuration.port) {
+  if (
+    !configHolder.configuration.url ||
+    !configHolder.configuration.host ||
+    !configHolder.configuration.port
+  ) {
     configHolder.configuration.url = `http://${addr}:${port}${basePath}`;
     configHolder.configuration.host = addr;
     configHolder.configuration.port = port;
@@ -89,26 +100,30 @@ function postRequest (data, addr, port, basePath) {
 
   const registerCycleInterval = configHolder.configuration.registerCycle;
   if (isNaN(registerCycleInterval) || registerCycleInterval <= 0) {
-    logger.warn(`'registerCycle' is not a valid positive number. ` +
-      `No registration request will be sent to the grid.`);
+    logger.warn(
+      `'registerCycle' is not a valid positive number. ` +
+        `No registration request will be sent to the grid.`
+    );
     return;
   }
   // initiate a new Thread
   let first = true;
-  logger.debug(`Starting auto register thread for the grid. ` +
-    `Will try to register every ${registerCycleInterval} ms.`);
-  setInterval(async function registerRetry () {
+  logger.debug(
+    `Starting auto register thread for the grid. ` +
+      `Will try to register every ${registerCycleInterval} ms.`
+  );
+  setInterval(async function registerRetry() {
     if (first) {
       first = false;
       await registerToGrid(regRequest, configHolder);
-    } else if (!await isAlreadyRegistered(configHolder)) {
+    } else if (!(await isAlreadyRegistered(configHolder))) {
       // make the http POST to the grid for registration
       await registerToGrid(regRequest, configHolder);
     }
   }, registerCycleInterval);
 }
 
-async function isAlreadyRegistered (configHolder) {
+async function isAlreadyRegistered(configHolder) {
   //check if node is already registered
   const id = configHolder.configuration.id;
   try {
@@ -129,5 +144,4 @@ async function isAlreadyRegistered (configHolder) {
   }
 }
 
-
 export default registerNode;

package/lib/logger.js

@@ -1,5 +1,4 @@
-import { logger } from 'appium-support';
-
+import {logger} from '@appium/support';
 
 let log = logger.getLogger('Appium');
 

package/lib/logsink.js

@@ -1,16 +1,14 @@
 import npmlog from 'npmlog';
-import { createLogger, format, transports } from 'winston';
-import { fs, logger } from 'appium-support';
-import dateformat from 'dateformat';
+import {createLogger, format, transports} from 'winston';
+import {fs, logger} from '@appium/support';
 import _ from 'lodash';
 
-
 // set up distributed logging before everything else
 logger.patchLogger(npmlog);
 global._global_npmlog = npmlog;
 
 // npmlog is used only for emitting, we use winston for output
-npmlog.level = 'silent';
+npmlog.level = 'info';
 const levels = {
   debug: 4,
   info: 3,
@@ -35,17 +33,20 @@ const npmToWinstonLevels = {
   error: 'error',
 };
 
+const encounteredPrefixes = [];
+
 let log = null;
-let timeZone = null;
+let useLocalTimeZone = false;
 
 // add the timestamp in the correct format to the log info object
 const timestampFormat = format.timestamp({
-  format () {
+  format() {
     let date = new Date();
-    if (!timeZone) {
-      date = new Date(date.valueOf() + date.getTimezoneOffset() * 60000);
+    if (useLocalTimeZone) {
+      date = new Date(date.valueOf() - date.getTimezoneOffset() * 60000);
     }
-    return dateformat(date, 'yyyy-mm-dd HH:MM:ss:l');
+    // '2012-11-04T14:51:06.157Z' -> '2012-11-04 14:51:06:157'
+    return date.toISOString().replace(/[TZ]/g, ' ').replace(/\./g, ':').trim();
   },
 });
 
@@ -55,14 +56,16 @@ const colorizeFormat = format.colorize({
 });
 
 // Strip the color marking within messages
-const stripColorFormat = format(function stripColor (info) {
+const stripColorFormat = format(function stripColor(info) {
   const code = /\u001b\[(\d+(;\d+)*)?m/g; // eslint-disable-line no-control-regex
   info.message = info.message.replace(code, '');
   return info;
 })();
 
-function createConsoleTransport (args, logLvl) {
-  return new (transports.Console)({
+function createConsoleTransport(args, logLvl) {
+  return new transports.Console({
+    // `name` is unsupported per winston's type declarations
+    // @ts-expect-error
     name: 'console',
     handleExceptions: true,
     exitOnError: false,
@@ -70,7 +73,7 @@ function createConsoleTransport (args, logLvl) {
     level: logLvl,
     stderrLevels: ['error'],
     format: format.combine(
-      format(function adjustDebug (info) {
+      format(function adjustDebug(info) {
         // prepend debug marker, and shift to `info` log level
         if (info.level === 'debug') {
           info.level = 'info';
@@ -80,15 +83,16 @@ function createConsoleTransport (args, logLvl) {
       })(),
       timestampFormat,
       args.logNoColors ? stripColorFormat : colorizeFormat,
-      format.printf(function printInfo (info) {
+      format.printf(function printInfo(info) {
         return `${args.logTimestamp ? `${info.timestamp} - ` : ''}${info.message}`;
       })
     ),
   });
 }
 
-function createFileTransport (args, logLvl) {
-  return new (transports.File)({
+function createFileTransport(args, logLvl) {
+  return new transports.File({
+    // @ts-expect-error
     name: 'file',
     filename: args.logFile,
     maxFiles: 1,
@@ -99,14 +103,14 @@ function createFileTransport (args, logLvl) {
     format: format.combine(
       stripColorFormat,
       timestampFormat,
-      format.printf(function printInfo (info) {
+      format.printf(function printInfo(info) {
         return `${info.timestamp} ${info.message}`;
       })
-    )
+    ),
   });
 }
 
-function createHttpTransport (args, logLvl) {
+function createHttpTransport(args, logLvl) {
   let host = '127.0.0.1';
   let port = 9003;
 
@@ -116,7 +120,8 @@ function createHttpTransport (args, logLvl) {
     port = parseInt(hostAndPort[1], 10);
   }
 
-  return new (transports.Http)({
+  return new transports.Http({
+    // @ts-expect-error
     name: 'http',
     host,
     port,
@@ -127,14 +132,14 @@ function createHttpTransport (args, logLvl) {
     level: logLvl,
     format: format.combine(
       stripColorFormat,
-      format.printf(function printInfo (info) {
+      format.printf(function printInfo(info) {
         return `${info.timestamp} ${info.message}`;
       })
     ),
   });
 }
 
-async function createTransports (args) {
+async function createTransports(args) {
   let transports = [];
   let consoleLogLevel = null;
   let fileLogLevel = null;
@@ -162,8 +167,9 @@ async function createTransports (args) {
       transports.push(createFileTransport(args, fileLogLevel));
     } catch (e) {
       // eslint-disable-next-line no-console
-      console.log(`Tried to attach logging to file '${args.logFile}' but an error ` +
-                  `occurred: ${e.message}`);
+      console.log(
+        `Tried to attach logging to file '${args.logFile}' but an error ` + `occurred: ${e.message}`
+      );
     }
   }
 
@@ -172,17 +178,33 @@ async function createTransports (args) {
       transports.push(createHttpTransport(args, fileLogLevel));
     } catch (e) {
       // eslint-disable-next-line no-console
-      console.log(`Tried to attach logging to Http at ${args.webhook} but ` +
-                  `an error occurred: ${e.message}`);
+      console.log(
+        `Tried to attach logging to Http at ${args.webhook} but ` +
+          `an error occurred: ${e.message}`
+      );
     }
   }
 
   return transports;
 }
 
-async function init (args) {
+function getColorizedPrefix(prefix) {
+  let prefixId = prefix.split('@')[0].trim();
+  prefixId = prefixId.split(' (')[0].trim();
+  if (encounteredPrefixes.indexOf(prefixId) < 0) {
+    encounteredPrefixes.push(prefixId);
+  }
+  // using a multiple of 16 should cause 16 colors to be created
+  const colorNumber = encounteredPrefixes.indexOf(prefixId) * 16;
+  // use the modulus to cycle around color wheel
+  return `\x1b[38;5;${colorNumber % 256}m${prefix}\x1b[0m`;
+}
+
+async function init(args) {
+  npmlog.level = 'silent';
+
   // set de facto param passed to timestamp function
-  timeZone = args.localTimezone;
+  useLocalTimeZone = args.localTimezone;
 
   // clean up in case we have initiated before since npmlog is a global object
   clear();
@@ -198,17 +220,22 @@ async function init (args) {
     let msg = logObj.message;
     if (logObj.prefix) {
       const prefix = `[${logObj.prefix}]`;
-      msg = `${args.logNoColors ? prefix : prefix.magenta} ${msg}`;
-    }
-    log[winstonLevel](msg);
-    if (args.logHandler && _.isFunction(args.logHandler)) {
-      args.logHandler(logObj.level, msg);
+      if (args.logNoColors) {
+        msg = `${prefix} ${msg}`;
+      } if (prefix === '[Appium]') {
+        msg = `${prefix.magenta} ${msg}`;
+      } else {
+        msg = `${getColorizedPrefix(prefix)} ${msg}`;
+      }
+      log[winstonLevel](msg);
+      if (args.logHandler && _.isFunction(args.logHandler)) {
+        args.logHandler(logObj.level, msg);
+      }
     }
-
   });
 }
 
-function clear () {
+function clear() {
   if (log) {
     for (let transport of _.keys(log.transports)) {
       log.remove(transport);
@@ -217,6 +244,5 @@ function clear () {
   npmlog.removeAllListeners('log');
 }
 
-
-export { init, clear };
+export {init, clear};
 export default init;