suitest-js-api 2.5.2 → 3.0.3

package/lib/utils/AuthContext.js

@@ -15,89 +15,40 @@ const texts = require('../texts');
  * List of request keys and methods allowed by context
  */
 const guestAllowed = {
-	http: {[endpoints.session]: ['POST']},
+	http: {},
 	ws: [],
 };
-const accessTokenAllowed = {
+
+const tokenAllowed = {
 	http: {
-		[endpoints.session]: ['POST'],
-		[endpoints.testPackGenTokens]: ['POST'],
 		[endpoints.apps]: ['GET'],
 		[endpoints.appById]: ['GET'],
 		[endpoints.appTags]: ['GET'],
 		[endpoints.appConfigs]: ['GET'],
 		[endpoints.appConfigById]: ['GET'],
-		[endpoints.appTestPacks]: ['GET'],
-		[endpoints.appTestPackById]: ['GET'],
 		[endpoints.appTestDefinitions]: ['GET'],
 		[endpoints.appTestDefinitionById]: ['GET'],
 		[endpoints.devices]: ['GET'],
 		[endpoints.testRun]: ['POST'],
 		[endpoints.testRunById]: ['GET', 'DELETE'],
 		[endpoints.testRunOnDevice]: ['DELETE'],
-		[endpoints.testPackRun]: ['POST'],
-		[endpoints.testPackRunById]: ['GET', 'DELETE'],
-	},
-	ws: [],
-};
-const interactiveSessionTokenAllowed = {
-	http: {
-		[endpoints.session]: ['POST'],
-		[endpoints.sessionClose]: ['POST'],
-		[endpoints.apps]: ['GET'],
-		[endpoints.appById]: ['GET'],
-		[endpoints.appTags]: ['GET'],
-		[endpoints.appConfigs]: ['GET'],
-		[endpoints.appConfigById]: ['GET'],
-		[endpoints.appTestPacks]: ['GET'],
-		[endpoints.appTestPackById]: ['GET'],
-		[endpoints.appTestDefinitions]: ['GET'],
-		[endpoints.appTestDefinitionById]: ['GET'],
-		[endpoints.devices]: ['GET'],
 	},
 	ws: [
-		wsContentTypes.startTest, wsContentTypes.endTest,
 		wsContentTypes.pairDevice, wsContentTypes.releaseDevice,
 		wsContentTypes.selectConfiguration, wsContentTypes.query,
 		wsContentTypes.eval, wsContentTypes.testLine,
 		wsContentTypes.takeScreenshot,
 	],
 };
-const automatedSessionTokenAllowed = {
-	http: {
-		[endpoints.session]: ['POST'],
-		[endpoints.sessionClose]: ['POST'],
-		[endpoints.apps]: ['GET'],
-		[endpoints.appById]: ['GET'],
-		[endpoints.appTags]: ['GET'],
-		[endpoints.appConfigs]: ['GET'],
-		[endpoints.appConfigById]: ['GET'],
-		[endpoints.appTestPacks]: ['GET'],
-		[endpoints.appTestPackById]: ['GET'],
-		[endpoints.appTestDefinitions]: ['GET'],
-		[endpoints.appTestDefinitionById]: ['GET'],
-		[endpoints.devices]: ['GET'],
-	},
-	ws: [
-		wsContentTypes.startTest, wsContentTypes.endTest,
-		wsContentTypes.pairDevice, wsContentTypes.releaseDevice,
-		wsContentTypes.selectConfiguration, wsContentTypes.query,
-		wsContentTypes.eval, wsContentTypes.testLine,
-		wsContentTypes.takeScreenshot
-	],
-};
+
 const allowedRequests = {
 	http: {
-		[sessionConstants.ACCESS_TOKEN]: accessTokenAllowed.http,
-		[sessionConstants.AUTOMATED]: automatedSessionTokenAllowed.http,
-		[sessionConstants.INTERACTIVE]: interactiveSessionTokenAllowed.http,
 		[sessionConstants.GUEST]: guestAllowed.http,
+		[sessionConstants.TOKEN]: tokenAllowed.http,
 	},
 	ws: {
-		[sessionConstants.ACCESS_TOKEN]: accessTokenAllowed.ws,
-		[sessionConstants.AUTOMATED]: automatedSessionTokenAllowed.ws,
-		[sessionConstants.INTERACTIVE]: interactiveSessionTokenAllowed.ws,
 		[sessionConstants.GUEST]: guestAllowed.ws,
+		[sessionConstants.TOKEN]: tokenAllowed.ws,
 	},
 };
 
@@ -134,7 +85,8 @@ class AuthContext extends Context {
 		super();
 
 		this.headers = {};
-		this.tokenKey = '';
+		this.tokenId = '';
+		this.tokenPassword = '';
 		super.setContext(sessionConstants.GUEST);
 	}
 
@@ -142,27 +94,20 @@ class AuthContext extends Context {
 	 * Set context. Update headers based on new context.
 	 *
 	 * @param {Symbol} newContext context symbol constant
-	 * @param {string|undefined} tokenId
-	 * @param {string|undefined} tokenPassword
+	 * @param {string|undefined} [tokenId]
+	 * @param {string|undefined} [tokenPassword]
 	 */
 	setContext(newContext, tokenId, tokenPassword) {
 		switch (newContext) {
-			case sessionConstants.ACCESS_TOKEN:
+			case sessionConstants.TOKEN:
 				super.setContext(newContext);
-				this.tokenKey = tokenId;
+				this.tokenId = tokenId;
+				this.tokenPassword = tokenPassword;
 				this.headers = {
-					'X-TokenId': tokenId,
-					'X-TokenPassword': tokenPassword,
+					'Authorization': `Basic ${Buffer.from(`${tokenId}:${tokenPassword}`).toString('base64')}`,
 				};
 				break;
 
-			case sessionConstants.AUTOMATED:
-			case sessionConstants.INTERACTIVE:
-				super.setContext(newContext);
-				this.tokenKey = tokenId;
-				this.headers = {'deviceAccessToken': tokenId};
-				break;
-
 			default:
 				this.clear();
 				break;
@@ -170,12 +115,12 @@ class AuthContext extends Context {
 	}
 
 	/**
-	 * Resest context to default
+	 * Reset context to default
 	 */
 	clear() {
 		super.setContext(sessionConstants.GUEST);
 		this.headers = {};
-		this.tokenKey = '';
+		this.tokenId = '';
 	}
 
 	/**
@@ -226,11 +171,7 @@ class AuthContext extends Context {
 	}
 
 	getToken() {
-		return this.tokenKey;
-	}
-
-	isInteractiveSession() {
-		return this.context === sessionConstants.INTERACTIVE;
+		return `${this.tokenId}:${this.tokenPassword}`;
 	}
 }
 

package/lib/utils/getDeviceInfo.js

@@ -1,21 +1,21 @@
 const request = require('../api/request');
 const endpoints = require('../api/endpoints');
 const fetch = require('node-fetch');
-const {filter} = require('ramda');
+const R = require('ramda');
 
 /**
  * Return devices details
  * @param {Object} instance main class instance
- * @param {array} devicesIds array of devices id's
+ * @param {array} devicesList array of devices id's
  * @returns {object}
  */
-async function getDevicesDetails({authContext}, devicesIds) {
+async function getDevicesDetails({authContext}, devicesList) {
 	const authorizeHttp = await authContext.authorizeHttp(endpoints.devices, {
 		method: 'GET',
 	});
 	let response = await request(
 		[endpoints.devices, null, {limit: 100}],
-		authorizeHttp
+		authorizeHttp,
 	);
 	let devices = [...response.values];
 
@@ -25,14 +25,20 @@ async function getDevicesDetails({authContext}, devicesIds) {
 		devices = [...devices, ...response.values];
 	}
 
-	const usedDevices = filter(d => devicesIds.includes(d.deviceId), devices);
+	return devicesList.reduce((result, d) => {
+		const device = devices.find(respDev => respDev.deviceId === d.device);
 
-	usedDevices.forEach(device => {
-		device.displayName = getDeviceName(device);
-		device.shortDisplayName = getDeviceName(device, true);
-	});
+		if (device) {
+			result.push({
+				...device,
+				...R.pick(['config', 'presetName'], d),
+				displayName: getDeviceName(device),
+				shortDisplayName: getDeviceName(device, true),
+			});
+		}
 
-	return usedDevices;
+		return result;
+	}, []);
 }
 
 /**

package/lib/utils/logger.js

@@ -198,8 +198,7 @@ const createLogger = (config, pairedDeviceContext) => {
 
 		const fontColor = method.color || stColors.suit;
 		const consoleMethod = console[method.consoleMethod];
-		// eslint-disable-next-line prefer-const
-		let {opType, logMessages} = extractOpType(messages);
+		const {opType, logMessages} = extractOpType(messages);
 
 		const logSource = devicePrefix();
 
@@ -283,7 +282,9 @@ const createLogger = (config, pairedDeviceContext) => {
 		},
 
 		intro: (message, ...params) => {
-			const paintedParams = params.map(param => stColors.bold(param));
+			const paintedParams = params.map(param => {
+				return param === null || param === undefined ? param : stColors.bold(param);
+			});
 
 			logger.log(stColors.suit(message(...paintedParams)));
 		},

package/lib/utils/{interactiveProgressHandler.js → progressHandler.js}

@@ -1,5 +1,5 @@
 /**
- * During an interactive test execution there are often periods of time
+ * During a test execution there are often periods of time
  * where longer waits occur and it is not immediately obvious why it is so.
  * In this case server sends WS events with content type 'progress'.
  * Description is printed to stdout.

package/lib/utils/sentry/Raven.js

@@ -46,7 +46,7 @@ const setUpRaven = (config, authContext) => {
 /**
  * Explicitly capture provided exception
  * @param {Error} error
- * @param {Object} extra
+ * @param {Object} [extra]
  * @returns {Promise<*>}
  */
 function captureException(error, extra) {

package/lib/utils/sessionStarter.js

@@ -1,19 +1,18 @@
-const sessionConstants = require('../constants/session');
-const {AUTOMATED} = require('../constants/modes');
+const {TOKEN} = require('../constants/modes');
 const chainPromise = require('./chainPromise');
 const {validate, validators} = require('../validation');
 const {captureException} = require('./sentry/Raven');
-const wsContentTypes = require('../api/wsContentTypes');
 const envVars = require('../constants/enviroment');
 const messageId = require('../constants/ipcMessageId');
 const ipcClient = require('../testLauncher/ipc/client');
-const {pick} = require('ramda');
-const {replWarnInteractive} = require('../texts');
+const {replWarn} = require('../texts');
+const wsContentTypes = require('../api/wsContentTypes');
 
 // Unchained commands
 const {openSessionUnchained: openSession} = require('../commands/openSession');
 const {pairDeviceUnchained: pairDevice} = require('../commands/pairDevice');
 const {setAppConfigUnchained: setAppConfig} = require('../commands/setAppConfig');
+const R = require('ramda');
 
 /**
  * Connect child process to launcher IPC server
@@ -33,47 +32,45 @@ const connectToMasterIpc = (port) => {
 };
 
 /**
- * Start automated or interactive session based on config
+ * Start suitest session based on config
  * @param {Object} suitest instance
  * @param {string} deviceId
- * @param {Object} config
+ * @param {string} configId
+ * @param {string} [presetName]
  */
-const bootstrapSession = async(suitest, deviceId, config) => {
+const bootstrapSession = async(suitest, {deviceId, configId, presetName}) => {
 	try {
-		// Run automated session
-		if (config.sessionType === AUTOMATED) {
-			validate(validators.SESSION_BOOTSTRAP_AUTOMATED, config, 'suitest automated config');
+		if (suitest.config.sessionType === TOKEN) {
+			validate(validators.SESSION_BOOTSTRAP_TOKEN, suitest.config, 'suitest token configuration');
 			await openSession(
 				suitest,
-				{sessionToken: config.sessionToken},
-				sessionConstants.AUTOMATED,
+				{
+					tokenId: suitest.config.tokenId,
+					tokenPassword: suitest.config.tokenPassword,
+				},
 			);
-			const pairDeviceResult = await pairDevice(suitest, deviceId);
 
-			suitest.appContext.setContext(pick(['appId', 'versionId', 'configId'], pairDeviceResult));
-			suitest.interactive = () => {
-				suitest.logger.warn(replWarnInteractive());
+			const configIdOrOverride = R.path([presetName, 'config'], suitest.config.presets);
+			const configOverride = R.is(Object, configIdOrOverride)
+				? R.omit(['configId'], configIdOrOverride)
+				: {};
 
-				return Promise.resolve();
-			};
+			await setAppConfig(suitest, configId, configOverride);
+			await pairDevice(suitest, deviceId);
 
-			return;
-		}
+			if (suitest.config.isDebugMode) {
+				await suitest.webSockets.send({type: wsContentTypes.enableDebugMode});
+			}
 
-		// Run interactive session
-		validate(validators.SESSION_BOOTSTRAP_INTERACTIVE, config, 'suitest intaractive config');
-		await openSession(
-			suitest,
-			{sessionToken: config.sessionToken},
-			sessionConstants.INTERACTIVE,
-		);
-		if (config.isDebugMode) {
-			await suitest.webSockets.send({type: wsContentTypes.enableDebugMode});
+			// add startREPL command only to child process instance and if running single device
+			suitest.startREPL = suitest.config.runsOnSingleDevice
+				? require('../../lib/commands/startREPL')
+				: () => {
+					suitest.logger.warn(replWarn());
+
+					return Promise.resolve();
+				};
 		}
-		// add interactive command only to child process instance and if mode is interactive
-		suitest.interactive = require('../../lib/commands/interactive');
-		await pairDevice(suitest, deviceId);
-		await setAppConfig(suitest, config.appConfigId);
 	} catch (error) {
 		await captureException(error);
 		// copy of handleLauncherError not imported to avoid cycle dependencies
@@ -94,12 +91,20 @@ const bootstrapSession = async(suitest, deviceId, config) => {
 /* istanbul ignore next */
 const connectToIpcAndBootstrapSession = async(suitest) => {
 	if (process.env[envVars.SUITEST_CHILD_PROCESS]) {
-		const [deviceId, ipcPort] = process.env[envVars.SUITEST_CHILD_PROCESS].split('|');
-		const config = await connectToMasterIpc(ipcPort);
+		const [deviceId, configId, ipcPort] = process.env[envVars.SUITEST_CHILD_PROCESS].split('|');
+
+		const suitestCtx = await connectToMasterIpc(ipcPort);
 
-		suitest.configuration.extend(config);
+		suitest.configuration.extend(suitestCtx);
 
-		await bootstrapSession(suitest, deviceId, config);
+		await bootstrapSession(
+			suitest,
+			{
+				deviceId,
+				configId,
+				presetName: process.env[envVars.SUITEST_PRESET_NAME],
+			},
+		);
 	}
 };
 

package/lib/utils/socketChainHelper.js

@@ -1,4 +1,5 @@
 const fs = require('fs');
+const path = require('path');
 const {isNil} = require('ramda');
 const assert = require('assert');
 const SuitestError = require('./SuitestError');
@@ -9,8 +10,8 @@ const {
 	responseMessageCode,
 } = require('./socketErrorMessages');
 const t = require('../texts');
-const {mapLogLevelsToTranslationModule} = require("./chainUtils");
-const {getSnippetLogs} = require("./socketErrorMessages");
+const {mapLogLevelsToTranslationModule} = require('./chainUtils');
+const {getSnippetLogs} = require('./socketErrorMessages');
 
 const assertionErrorTypes = ['queryFailed', 'appRunning', 'appNotRunning', 'queryTimeout'];
 
@@ -63,7 +64,11 @@ const processServerResponse = (logger, verbosity) =>
 				'cookieValue',
 				'cookieExists',
 				'elementProps',
+				'elementCssProps',
 				'elementExists',
+				'elementHandles',
+				'elementHandle',
+				'attributes',
 				'execute',
 				'location',
 			].find(key => key in res);
@@ -121,12 +126,16 @@ const processServerResponse = (logger, verbosity) =>
 			} else if (data.dataFormat === 'base64') {
 				return res.buffer.toString('base64');
 			} else if (data.fileName) {
-				try {
-					return fs.promises.writeFile(data.fileName, res.buffer);
-				} catch (e) {
-					logger.error(e.message);
-					throwErr(e);
-				}
+				const dir = path.dirname(data.fileName);
+
+				return fs.promises
+					.access(dir)
+					.catch(() => fs.promises.mkdir(dir))
+					.then(() => fs.promises.writeFile(data.fileName, res.buffer))
+					.catch(e => {
+						logger.error(e.message);
+						throwErr(e);
+					});
 			}
 
 			return;

package/lib/utils/stackTraceParser.js

@@ -22,10 +22,18 @@ function fetchSource(error, contextSize = 5) {
 	return sourceLines.slice(start, end);
 }
 
+/**
+* @typedef {Object} StackTraceItem
+* @property {number} line
+* @property {number} column
+* @property {string} function
+* @property {string} file
+*/
+
 /**
  * Parse error stack trace
  * @param {Error|undefined} [error]
- * @returns {string|Object} parsed or stringified stack trace
+ * @returns {string|Array<StackTraceItem>} parsed or stringified stack trace
  * @example [{
  * 	"line": 4,
  *	"column": 11,
@@ -118,6 +126,21 @@ function getFirstStackLine(stack) {
 	return stripAbsolutePaths(stripSuitestCodeFromStack(stack)).split('\n').find(isStackLine) || '';
 }
 
+/**
+ * @description get first non suitest stack item.
+ * @returns {void | StackTraceItem}
+ */
+function getFirstNotSuitestStackItem(error = new Error()) {
+	/** @type {StackTraceItem[]} */
+	const parsedStack = stackTraceParser(error);
+
+	if (!Array.isArray(parsedStack)) {
+		return;
+	}
+
+	return parsedStack.find(x => !isSuitestMethod(x.file));
+}
+
 /**
  * Remember call stack before function execution
  * If error is thrown, prepend error stack with cached stack
@@ -146,6 +169,7 @@ module.exports = {
 	prependStack,
 	stackTraceWrapper,
 	getFirstStackLine,
+	getFirstNotSuitestStackItem,
 	isStackLine,
 	stripAbsolutePaths,
 };

package/lib/utils/testHelpers/mockHelpers.js

@@ -1,10 +1,8 @@
 /* istanbul ignore file */
 
-const sinon = require('sinon');
 const mock = require('mock-require');
 const testLauncherHelper = require('../testLauncherHelper');
 
 mock('../testLauncherHelper', {
 	...testLauncherHelper,
-	promptPassword: sinon.stub().resolves('password'),
 });

package/lib/utils/testHelpers/mockWebSocket.js

@@ -7,7 +7,7 @@ const {v1: uuid} = require('uuid');
 const {config} = require('../../../index');
 const SuitestError = require('../SuitestError');
 const texts = require('../../texts');
-const {handleProgress} = require('../interactiveProgressHandler');
+const {handleProgress} = require('../progressHandler');
 const mock = require('mock-require');
 
 let ws = null,

package/lib/utils/testHelpers/testLauncherTest.js

@@ -4,9 +4,6 @@ require('../../../config/setTestConfig');
 require('../../utils/testHelpers/mockWebSocket');
 const testServer = require('../../utils/testServer');
 const nock = require('nock');
-const makeUrlFromArray = require('../makeUrlFromArray');
-const endpoints = require('../../api/endpoints');
-const config = require('../../../config');
 const stubDeviceInfoFeed = require('./mockDeviceInfo');
 
 process.on('exit', () => {
@@ -17,48 +14,8 @@ process.on('exit', () => {
 async function setUp() {
 	await testServer.restart();
 
-	// automated
-	nock(config.apiUrl)
-		.post(makeUrlFromArray([endpoints.testPackGenTokens, {id: 10}]))
-		.reply(
-			200,
-			{
-				deviceAccessToken: 'deviceAccessToken',
-				testPack: {
-					devices: [{deviceId: '1'}],
-				},
-			}
-		);
-
 	stubDeviceInfoFeed();
 
-	// automated no devices
-	nock(config.apiUrl)
-		.post(makeUrlFromArray([endpoints.testPackGenTokens, {id: 20}]))
-		.reply(
-			200,
-			{
-				deviceAccessToken: 'deviceAccessToken',
-				testPack: {
-					devices: [],
-				},
-			}
-		);
-
-	// interactive
-	nock(config.apiUrl)
-		.post(makeUrlFromArray([endpoints.session, {
-			username: 'userEmail',
-			password: 'userPass',
-			orgId: 'orgId',
-		}]))
-		.reply(200, {deviceAccessToken: 'deviceAccessToken'});
-
-	// close session
-	nock(config.apiUrl)
-		.post(endpoints.sessionClose)
-		.reply(200, {});
-
 	const suitest = require('../../../index');
 
 	suitest.logger.success = () => null;