appium 2.0.0-beta.35 → 2.0.0-beta.37

package/lib/extension/plugin-config.js

@@ -1,4 +1,3 @@
-
 import _ from 'lodash';
 import {ExtensionConfig} from './extension-config';
 import log from '../logger';
@@ -8,7 +7,6 @@ import {PLUGIN_TYPE} from '../constants';
  * @extends {ExtensionConfig<PluginType>}
  */
 export class PluginConfig extends ExtensionConfig {
-
   /**
    * A mapping of {@link Manifest} instances to {@link PluginConfig} instances.
    *
@@ -19,95 +17,97 @@ export class PluginConfig extends ExtensionConfig {
    * @type {WeakMap<Manifest,PluginConfig>}
    * @private
    */
-   static _instances = new WeakMap();
+  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
-   * @param {PluginConfigOptions} [opts]
    */
-   constructor (manifest, {extData, logFn} = {}) {
-     super(PLUGIN_TYPE, manifest, logFn);
+  constructor(manifest) {
+    super(PLUGIN_TYPE, manifest);
+  }
 
-     if (extData) {
-       this.validate(extData);
-     }
-   }
+  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
-    * @param {PluginConfigOptions} [opts]
-    * @throws If `manifest` already associated with a `PluginConfig`
-    * @returns {PluginConfig}
-    */
-   static create (manifest, {extData, logFn} = {}) {
-     const instance = new PluginConfig(manifest, {logFn, extData});
-     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;
-   }
+  /**
+   * 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);
-   }
+  /**
+   * 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('../../types/appium-manifest').ExtManifest<PluginType>} pluginData
+   * @param {import('appium/types').ExtManifest<PluginType>} pluginData
    * @returns {string}
    */
-   extensionDesc (pluginName, {version}) {
-     return `${pluginName}@${version}`;
-   }
+  extensionDesc(pluginName, {version}) {
+    return `${pluginName}@${version}`;
+  }
 
-   /**
+  /**
    *
    * @param {(keyof PluginRecord)[]} activeNames
    * @returns {void}
    */
-   print (activeNames) {
-     const pluginNames = Object.keys(this.installedExtensions);
+  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;
-     }
+    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}`);
-     }
+    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');
-     }
-   }
+    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
- * @property {import('../../types/appium-manifest').PluginRecord} [extData] - Extension data
  */
 
-
 /**
- * @typedef {import('../../types/appium-manifest').PluginRecord} PluginRecord
- * @typedef {import('../../types').PluginType} PluginType
- * @typedef {import('../../types/external-manifest').ExtMetadata<PluginType>} PluginMetadata
+ * @typedef {import('appium/types').PluginRecord} PluginRecord
+ * @typedef {import('@appium/types').PluginType} PluginType
+ * @typedef {import('appium/types').ExtMetadata<PluginType>} PluginMetadata
  * @typedef {import('./manifest').Manifest} Manifest
  */

package/lib/grid-register.js

@@ -1,9 +1,8 @@
 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}`;
@@ -16,20 +15,24 @@ const hubUri = (config) => {
  * @param {number} [port] - Bind to this port
  * @param {string} [basePath] - Base path for the grid
  */
-async function registerNode (data, addr, port, basePath) {
+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}`);
+      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}`);
+      logger.errorAndThrow(
+        `Syntax error in node configuration file ${configFilePath}: ${err.message}`
+      );
       return;
     }
   }
@@ -37,20 +40,21 @@ async function registerNode (data, addr, port, basePath) {
   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 (configHolder, addr, port, basePath) {
+function postRequest(configHolder, addr, port, basePath) {
   // Move Selenium 3 configuration properties to configuration object
   if (!_.has(configHolder, 'configuration')) {
     let configuration = {};
@@ -68,7 +72,11 @@ function postRequest (configHolder, 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;
@@ -92,26 +100,30 @@ function postRequest (configHolder, 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 {
@@ -132,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,15 +1,14 @@
 import npmlog from 'npmlog';
-import { createLogger, format, transports } from 'winston';
-import { fs, logger } from '@appium/support';
+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,
@@ -39,16 +38,13 @@ 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 (useLocalTimeZone) {
       date = new Date(date.valueOf() - date.getTimezoneOffset() * 60000);
     }
     // '2012-11-04T14:51:06.157Z' -> '2012-11-04 14:51:06:157'
-    return date.toISOString()
-      .replace(/[TZ]/g, ' ')
-      .replace(/\./g, ':')
-      .trim();
+    return date.toISOString().replace(/[TZ]/g, ' ').replace(/\./g, ':').trim();
   },
 });
 
@@ -58,14 +54,14 @@ 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',
@@ -75,7 +71,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';
@@ -85,15 +81,15 @@ 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,
@@ -105,14 +101,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;
 
@@ -122,7 +118,7 @@ function createHttpTransport (args, logLvl) {
     port = parseInt(hostAndPort[1], 10);
   }
 
-  return new (transports.Http)({
+  return new transports.Http({
     // @ts-expect-error
     name: 'http',
     host,
@@ -134,14 +130,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;
@@ -169,8 +165,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}`
+      );
     }
   }
 
@@ -179,15 +176,18 @@ 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) {
+async function init(args) {
+  npmlog.level = 'silent';
   // set de facto param passed to timestamp function
   useLocalTimeZone = args.localTimezone;
 
@@ -211,11 +211,10 @@ async function init (args) {
     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);
@@ -224,6 +223,5 @@ function clear () {
   npmlog.removeAllListeners('log');
 }
 
-
-export { init, clear };
+export {init, clear};
 export default init;