@appium/support

What is @appium/support?

@appium/support is a utility library that provides various helper functions and classes to support Appium's core functionalities. It includes utilities for file system operations, logging, process management, and more.

What are @appium/support's main functionalities?

File System Utilities

This feature provides various file system utilities such as reading, writing, and manipulating files. The code sample demonstrates how to create a file, write to it, and read its content.

const { fs } = require('@appium/support');

async function createFile() {
  const filePath = './example.txt';
  await fs.writeFile(filePath, 'Hello, world!');
  const content = await fs.readFile(filePath, 'utf8');
  console.log(content); // Output: Hello, world!
}

createFile();

Logging

This feature provides a logging utility that allows you to log messages at different levels (info, warn, error). The code sample demonstrates how to create a logger and log messages at different levels.

const { logger } = require('@appium/support');

const log = logger.getLogger('example');
log.info('This is an info message');
log.warn('This is a warning message');
log.error('This is an error message');

Process Management

This feature provides utilities for managing system processes, such as executing shell commands. The code sample demonstrates how to execute a shell command and handle its output.

const { exec } = require('@appium/support');

async function runCommand() {
  const { stdout, stderr } = await exec('echo Hello, world!');
  if (stderr) {
    console.error(`Error: ${stderr}`);
  } else {
    console.log(`Output: ${stdout}`); // Output: Hello, world!
  }
}

runCommand();

Other packages similar to @appium/support

fs-extra

fs-extra is a package that extends the native Node.js file system module with additional methods and promises support. It provides similar file system utilities as @appium/support but focuses solely on file system operations.

winston

winston is a versatile logging library for Node.js that provides a wide range of logging capabilities, including multiple transports, log levels, and formatting options. It offers more advanced logging features compared to the logging utility in @appium/support.

child_process

child_process is a core Node.js module that provides the ability to spawn and manage system processes. It offers similar process management functionalities as the exec utility in @appium/support but is more low-level and requires more boilerplate code.

README

appium-support

Utility functions used to support libs used across appium packages.

npm install appium-support

Appium, as of version 1.5 is all based on promises, so this module provides promise wrappers for some common operations.

Most notably, we wrap fs for file system commands. Note the addition of hasAccess. Also note that fs.mkdir doesn't throw an error if the directory already exists, it will just resolve.

Methods

• system.isWindows

• system.isMac

• system.isLinux

• system.isOSWin64

• system.arch

• system.macOsxVersion

• util.hasContent - returns true if input string has content

• util.hasValue - returns true if input value is not undefined and no null

• util.escapeSpace

• util.escapeSpecialChars

• util.localIp

• util.cancellableDelay

• util.multiResolve - multiple path.resolve

• util.unwrapElement - parse an element ID from an element object: e.g.: {ELEMENT: 123, "element-6066-11e4-a52e-4f735466cecf": 123} returns 123

• util.wrapElement - convert an element ID to an element object of the form: e.g.: 123 returns {ELEMENT: 123, "element-6066-11e4-a52e-4f735466cecf": 123}

• fs.hasAccess - use this over fs.access

• fs.exists - calls fs.hasAccess

• fs.rimraf

• fs.mkdir - doesn't throw an error if directory already exists

• fs.copyFile

• fs.open

• fs.close

• fs.access

• fs.readFile

• fs.writeFile

• fs.write

• fs.readlink

• fs.chmod

• fs.unlink

• fs.readdir

• fs.stat

• fs.rename

• fs.md5

• plist.parsePlistFile

• plist.updatePlistFile

• mkdirp

• logger

• zip.extractAllTo - Extracts contents of a zipfile to a directory

• zip.readEntries - Reads entries (files and directories) of a zipfile

• zip.toInMemoryZip - Converts a directory into a base64 zipfile

logger

Basic logger defaulting to npmlog with special consideration for running tests (doesn't output logs when run with _TESTING=1 in the env).

Logging levels

There are a number of levels, exposed as methods on the log object, at which logging can be made. The built-in ones correspond to those of npmlog, and are: silly, verbose, info, http, warn, and error. In addition there is a debug level.

The default threshold level is verbose.

The logged output, by default, will be level prefix message. So

import { logger } from 'appium-support';
let log = logger.getLogger('mymodule');
log.warn('a warning');`

Will produce

warn mymodule a warning

Environment variables

There are two environment variable flags that affect the way appium-base-driver logger works.

_TESTING

• _TESTING=1 stops output of logs when set to 1.

_FORCE_LOGS

• This flag, when set to 1, reverses the _TESTING

Usage

log.level

• get and set the threshold level at which to display the logs. Any logs at or above this level will be displayed. The special level silent will prevent anything from being displayed ever. See npmlog#level.

log[level](message)

• logs to level

  import { logger } from 'appium-support';
  let log = logger.getLogger('mymodule');
  
  log.info('hi!');
  // => info mymodule hi!
  

log.unwrap()

• retrieves the underlying npmlog object, in order to manage how logging is done at a low level (e.g., changing output streams, retrieving an array of messages, adding log levels, etc.).

  import { getLogger } from 'appium-base-driver';
  let log = getLogger('mymodule');
  
  log.info('hi!');
  
  let npmlogger = log.unwrap();
  
  // any `npmlog` methods
  let logs = npmlogger.record;
  // logs === [ { id: 0, level: 'info', prefix: 'mymodule', message: 'hi!', messageRaw: [ 'hi!' ] }]
  

log.errorAndThrow(error)

• logs the error passed in, at error level, and then throws the error. If the error passed in is not an instance of Error (either directly, or a subclass of Error) it will be wrapped in a generic Error object.

  import { getLogger } from 'appium-base-driver';
  let log = getLogger('mymodule');
  
  // previously there would be two lines
  log.error('This is an error');
  throw new Error('This is an error');
  
  // now is compacted
  log.errorAndThrow('This is an error');