suitest-js-api 2.5.2 → 3.0.3

package/lib/utils/testLauncherHelper.js

@@ -1,4 +1,3 @@
-const read = require('read');
 const ramda = require('ramda');
 const path = require('path');
 const moment = require('moment');
@@ -12,17 +11,14 @@ const texts = require('../texts');
 
 const Queue = require('./Queue');
 const {registerProcess} = require('../testLauncher/processReaper');
-const {startTestPackUnchained} = require('../commands/startTestPack');
 const envVars = require('../constants/enviroment');
 
 const {version} = require('../../package.json');
 const {stripAnsiChars} = require('./stringUtils');
 
-const {AUTOMATED, INTERACTIVE, TEST_COMMAND} = require('../constants/modes');
+const {TEST_COMMAND} = require('../constants/modes');
 
 const {fetchLatestSuitestVersion, warnNewVersionAvailable} = require('./packageMetadataHelper');
-const SuitestError = require('./SuitestError');
-const t = require('../texts');
 
 const ipcServer = require('../testLauncher/ipc/server');
 const messageId = require('../constants/ipcMessageId');
@@ -56,31 +52,9 @@ function handleChildResult(finishedWithErrors) {
 	}
 }
 
-/**
- * Prompt user password.
- * If nothing provided, ask again.
- */
-function promptPassword() {
-	return new Promise((resolve) => read({
-		prompt: texts['tl.promptPassword'](),
-		silent: true,
-		replace: '*',
-	}, (err, pass) => {
-		/* istanbul ignore if */
-		if (err) {
-			// prompt dismissed with CTRL+C or the like.
-			process.stdout.write('\n');
-		} else if (!pass) {
-			resolve(promptPassword());
-		} else {
-			resolve(pass);
-		}
-	}));
-}
-
 /**
  * Validate test launcher's args based on session type
- * @param {String} type session type "AUTOMATED" or "INTERACTIVE", "TEST_COMMAND"
+ * @param {'TEST_COMMAND'|'TOKEN'} type session type
  * @param {Object} args test launcher arguments
  */
 function validateInput(type, args) {
@@ -91,7 +65,7 @@ function validateInput(type, args) {
 
 		validation.validate(
 			validation.validators[`TEST_LAUNCHER_${type}`],
-			args, msg
+			args, msg,
 		);
 	} catch (error) {
 		log.argsValidationError(error);
@@ -169,10 +143,10 @@ function isDebugMode({inspectBrk, inspect}) {
 }
 
 /**
- * Throw error and exit process when user wants to run debugging in automated session
+ * Throw error and exit process when user wants to run debugging with multiply devices
  */
-function throwDebugInAutomatedError() {
-	logger.error(texts['tl.inspectOnlyForInteractiveMode']());
+function throwDebugForManyDevicesError() {
+	logger.error(texts['tl.inspectOnlyForSingleDevice']());
 	process.exit(1);
 }
 
@@ -181,10 +155,10 @@ function throwDebugInAutomatedError() {
  * @param {Array} cmdArgv - user test command and it's parameters
  * @param {Object} ownArgv - implicitly derived launcher parameters
  * @param {Object} options - child process environment options
- * @param {string} runMode - suitest execution mode (interactive|automated)
+ * @param {Boolean} singleDeviceOnly - overall execution will be ran for single device
  * @returns {ChildProcess} - spawned child process
  */
-async function launchChild(cmdArgv, ownArgv, options, runMode) {
+async function launchChild(cmdArgv, ownArgv, options, singleDeviceOnly) {
 	const [command, ...args] = cmdArgv;
 	const debugOption = getDebugOption(ownArgv);
 
@@ -192,14 +166,14 @@ async function launchChild(cmdArgv, ownArgv, options, runMode) {
 		args.unshift(debugOption);
 	}
 
-	if (runMode === INTERACTIVE) {
+	if (singleDeviceOnly) {
 		options.stdio = 'pipe';
 	}
 
 	return cp.spawn(
 		command,
 		args,
-		options
+		options,
 	);
 }
 
@@ -251,16 +225,16 @@ function addLauncherIpcListeners() {
  * @param {ChildProcess} child - the child process instance running the test
  * @param {Function} onExit - callback function to call when the process finishes
  * @param {WritableStream} logStream - the output stream of the child process.
- * @param {String} runMode - suitest test execution mode
+ * @param {Boolean} singleDeviceOnly - overall execution will be ran for single device
  */
-function attachIO(child, onExit, logStream, runMode) {
+function attachIO(child, onExit, logStream, singleDeviceOnly) {
 	const [childIn, childOut, childErr] = child.stdio;
 	const logIo = chunk => logOutput(child, chunk, logStream);
 
 	registerProcess(child);
 
-	// in interactive mode pipe stdin so that console is not confused by REPL
-	if (runMode === INTERACTIVE) {
+	// for single device execution pipe stdin so that console is not confused by REPL
+	if (singleDeviceOnly) {
 		keypress(process.stdin);
 		process.stdin.pipe(childIn);
 		childIn.on('data', logIo);
@@ -282,14 +256,14 @@ function attachIO(child, onExit, logStream, runMode) {
  * @param {Array} cmdArgv - user test command and it's parameters
  * @param {Object} ownArgv - implicitly derived launcher parameters
  * @param {Object} device - full device information
- * @param {String} runMode - Suitest execution mode (interactive|automated)
+ * @param {Boolean} singleDeviceOnly - overall execution will be ran for single device
  * @param {number} ipcPort
  * @returns {Promise<any>}
  */
-async function runTestOnDevice(cmdArgv, ownArgv, device, runMode, ipcPort) {
+async function runTestOnDevice(cmdArgv, ownArgv, device, singleDeviceOnly, ipcPort) {
 	const {logDir} = ownArgv;
-	const options = getChildOptions(device.deviceId, ipcPort);
-	const child = await launchChild(cmdArgv, ownArgv, options, runMode);
+	const options = getChildOptions(device, ipcPort);
+	const child = await launchChild(cmdArgv, ownArgv, options, singleDeviceOnly);
 	const logStream = getDeviceLogStream(device, cmdArgv, new Date(), logDir);
 
 	return new Promise(resolve => {
@@ -297,34 +271,34 @@ async function runTestOnDevice(cmdArgv, ownArgv, device, runMode, ipcPort) {
 			cmdArgv.join(' '),
 			ownArgv.orgId,
 			ownArgv.appConfigId,
-			runMode === AUTOMATED ? ownArgv.testPackId : '',
-			new Date()
+			new Date(),
 		));
 
 		const onExit = (exitCode, signal) => {
 			logStream && logStream.write(texts.fileLogCompleted(
-				exitCode, signal
+				exitCode, signal,
 			));
 			resolve(exitCode, signal);
 		};
 
-		attachIO(child, onExit, logStream, runMode);
+		attachIO(child, onExit, logStream, singleDeviceOnly);
 	});
 }
 
 /**
  * Prepares environment for the child process.
  *
- * @param {string} deviceId - id of the device
+ * @param {string} device - device object. deviceId and config should be provided.
  * @param {number} port - ipc port
  * @returns {{shell: true, env: Object}}
  */
-function getChildOptions(deviceId, port) {
+function getChildOptions(device, port) {
 	return {
 		shell: true,
 		env: {
 			...process.env,
-			[envVars.SUITEST_CHILD_PROCESS]: `${deviceId}|${port}`,
+			[envVars.SUITEST_CHILD_PROCESS]: `${device.deviceId}|${device.config}|${port}`,
+			[envVars.SUITEST_PRESET_NAME]: device.presetName,
 			FORCE_COLOR: true,
 			NODE_NO_READLINE: 1, // enable repl in advanced consoles
 		},
@@ -332,37 +306,7 @@ function getChildOptions(deviceId, port) {
 }
 
 /**
- * Prepares data for execution of the test pack
- *
- * @param {Object} ownArgv - implicitly derived launcher paratemers
- * @returns {Promise<{devices, deviceAccessToken: *}>}
- */
-async function prepareTestPackExecution(ownArgv) {
-	const {tokenKey, tokenId, tokenPassword, testPackId} = ownArgv;
-
-	const testPackInfo = await startTestPackUnchained(suitest, {
-		accessTokenKey: tokenKey || tokenId,
-		accessTokenPassword: tokenPassword,
-		testPackId,
-	});
-
-	const {pluck, path} = ramda;
-	const {deviceAccessToken} = testPackInfo;
-	const devices = pluck('deviceId', path(['testPack', 'devices'], testPackInfo));
-	const deviceCount = devices.length;
-
-	if (!deviceCount) {
-		throw new SuitestError(t['errorType.testPackNoDevices'](), SuitestError.INVALID_INPUT);
-	}
-
-	return {
-		devices,
-		deviceAccessToken,
-	};
-}
-
-/**
- * Runs test pack on all devices in automated mode
+ * Runs all devices by spawning subprocesses
  *
  * @param {Array} cmdArgv - user command and it's arguments
  * @param {Object} ownArgv - implicitly derived parameters
@@ -372,17 +316,20 @@ async function prepareTestPackExecution(ownArgv) {
  */
 function runAllDevices(cmdArgv, ownArgv, devices, ipcPort) {
 	const tests = devices.map(device => () => runTestOnDevice(
-		cmdArgv, ownArgv, device, AUTOMATED, ipcPort
+		cmdArgv,
+		ownArgv,
+		device,
+		devices.length === 1,
+		ipcPort,
 	));
 
 	const queue = new Queue(ownArgv.concurrency, tests);
 
 	logger.intro(
-		texts.launcherSummaryAutomated,
-		ownArgv.testPackId,
+		texts.launcherSummary,
 		cmdArgv.join(' '),
 		ownArgv.logDir,
-		...devices.map(device => device.displayName)
+		...devices.map(device => device.displayName),
 	);
 
 	return queue.start().then(result => {
@@ -391,26 +338,15 @@ function runAllDevices(cmdArgv, ownArgv, devices, ipcPort) {
 				const code = res.result.code || res.result;
 
 				return res.result.error || code !== 0;
-			}
+			},
 		);
 
-		log.finalAutomated(failedDevices.length, result.length - failedDevices.length);
-		warnNewVersionAvailable(version, suitestVersion);
+		log.final(failedDevices.length, result.length - failedDevices.length);
+		warnNewVersionAvailable(logger, version, suitestVersion);
 		handleChildResult(failedDevices.length !== 0);
 	});
 }
 
-/**
- * Completing steps for interactive run
- *
- * @param {Boolean} withError
- */
-function finishInteractive(withError) {
-	log.finalInteractive(withError);
-	warnNewVersionAvailable(version, suitestVersion);
-	handleChildResult(withError);
-}
-
 /**
  * Get's the version of the latest published suitest-js-api package
  * @returns {Promise<String>}
@@ -428,7 +364,7 @@ async function getVersion() {
  * @param {number} concurrency
  * @modifies emitter
  */
-function increaseMaxListeners(emitter, deviceCount, concurrency) {
+function increaseMaxListeners(emitter, deviceCount, concurrency= 0) {
 	const threadCount = concurrency === 0 ? deviceCount : Math.min(concurrency, deviceCount);
 
 	emitter.setMaxListeners(emitter.getMaxListeners() + threadCount * 2);
@@ -437,16 +373,13 @@ function increaseMaxListeners(emitter, deviceCount, concurrency) {
 module.exports = {
 	handleLauncherError,
 	handleChildResult,
-	promptPassword,
 	validateInput,
-	prepareTestPackExecution,
 	runTestOnDevice,
 	runAllDevices,
-	finishInteractive,
 	getVersion,
 	isDebugMode,
 	getDebugOption,
 	addLauncherIpcListeners,
-	throwDebugInAutomatedError,
+	throwDebugForManyDevicesError,
 	increaseMaxListeners,
 };

package/lib/validation/elementPropTypes.js

@@ -92,6 +92,8 @@ const ELEMENT_PROP_TYPES = {
 	[ELEMENT_PROP.EXTENDS]: 'string',
 	[ELEMENT_PROP.UI_ELEMENT_ID]: 'string',
 	[ELEMENT_PROP.INDEX]: 'integer',
+	[ELEMENT_PROP.OFFSET_TOP]: 'number',
+	[ELEMENT_PROP.OFFSET_LEFT]: 'number',
 };
 
 Object.freeze(ELEMENT_PROP_TYPES);

package/lib/validation/jsonSchemas.js

@@ -28,7 +28,7 @@ schemas[validationKeys.CONFIG_OVERRIDE] = {
 			'type': 'array',
 			'items': {'type': 'string'},
 		},
-		'freezeRules': {
+		'mapRules': {
 			'type': 'array',
 			'items': {
 				'type': 'object',
@@ -62,26 +62,6 @@ schemas[validationKeys.CONFIG_OVERRIDE] = {
 	},
 };
 
-schemas[validationKeys.START_TEST_PACK] = {
-	'type': 'object',
-	'required': ['testPackId', 'includeChangelist'],
-	'properties': {
-		'testPackId': {'type': ['number', 'string']},
-		'accessTokenKey': {'type': 'string'},
-		'accessTokenPassword': {'type': 'string'},
-		'config': schemas[validationKeys.CONFIG_OVERRIDE],
-		'includeChangelist': {'type': 'boolean'},
-		'metadata': {
-			'type': 'object',
-			'properties': {
-				'version': {'type': 'string'},
-				'hash': {'type': 'string'},
-				'link': {'type': 'string'},
-			},
-		},
-	},
-};
-
 schemas[validationKeys.LAUNCH_MODE] = {
 	'type': 'string',
 	'enum': Object.values(LAUNCH_MODE),
@@ -104,29 +84,11 @@ schemas[validationKeys.UUID] = {
 
 schemas[validationKeys.OPEN_SESSION] = {
 	'type': 'object',
-	'oneOf': [
-		{
-			'required': ['username', 'password', 'orgId'],
-			'properties': {
-				'username': {'type': 'string'},
-				'password': {'type': 'string'},
-				'orgId': {'type': 'string'},
-			},
-		},
-		{
-			'required': ['sessionToken'],
-			'properties': {
-				'sessionToken': {'type': 'string'},
-			},
-		},
-		{
-			'required': ['accessTokenKey', 'accessTokenPassword'],
-			'properties': {
-				'accessTokenKey': {'type': 'string'},
-				'accessTokenPassword': {'type': 'string'},
-			},
-		},
-	],
+	'required': ['tokenId', 'tokenPassword'],
+	'properties': {
+		'tokenId': {'type': 'string'},
+		'tokenPassword': {'type': 'string'},
+	},
 };
 
 schemas[validationKeys.STRING] = {
@@ -148,23 +110,31 @@ schemas[validationKeys.ELEMENT_SELECTOR] = {
 		'xpath': {'type': 'string'},
 		'attributes': {'type': 'string'},
 		'text': {'type': 'string'},
+		'linkText': {'type': 'string'},
+		'partialLinkText': {'type': 'string'},
 		'position': {'type': 'string'},
 		'size': {'type': 'string'},
 		'color': {'type': 'string'},
 		'index': {
 			'type': 'integer',
 			'exclusiveMinimum': 0,
-		}
+		},
+		'handle': schemas[validationKeys.NON_EMPTY_STRING],
+		'active': {'type': 'boolean'},
 	},
 	'anyOf': [
 		{'required': ['css']},
 		{'required': ['xpath']},
 		{'required': ['attributes']},
 		{'required': ['text']},
+		{'required': ['linkText']},
+		{'required': ['partialLinkText']},
 		{'required': ['position']},
 		{'required': ['size']},
 		{'required': ['color']},
 		{'required': ['apiId']},
+		{'required': ['handle']},
+		{'required': ['active']},
 	],
 };
 
@@ -328,63 +298,56 @@ schemas[validationKeys.RESPONSE_MATCHES] = {
 	},
 };
 
-schemas[validationKeys.TEST_LAUNCHER_AUTOMATED] = {
+schemas[validationKeys.TEST_LAUNCHER_TOKEN] = {
 	'type': 'object',
-	'oneOf': [
-		{
-			'required': ['tokenKey', 'tokenPassword', 'testPackId'],
-			'properties': {
-				'tokenKey': {'type': 'string'},
-				'tokenPassword': {'type': 'string'},
-				'testPackId': {'type': ['number', 'string']},
-			},
-		},
-		{
-			'required': ['tokenId', 'tokenPassword', 'testPackId'],
-			'properties': {
-				'tokenId': {'type': 'string'},
-				'tokenPassword': {'type': 'string'},
-				'testPackId': {'type': ['number', 'string']},
+	'required': ['tokenId', 'tokenPassword'],
+	'properties': {
+		'tokenId': {'type': 'string'},
+		'tokenPassword': {'type': 'string'},
+		'presets': {
+			'type': 'object',
+			'additionalProperties': {
+				'type': 'object',
+				'properties': {
+					'device': {
+						'oneOf': [
+							{'type': 'string'},
+							{
+								'type': 'object',
+								'properties': {
+									'deviceId': {'type': 'string'},
+								},
+								'additionalProperties': false,
+							},
+						],
+					},
+					'config': {
+						'oneOf': [
+							{'type': 'string'},
+							{
+								'type': 'object',
+								'properties': {
+									'configId': {'type': 'string'},
+								},
+								'additionalProperties': false,
+							},
+						],
+					},
+				},
 			},
-		},
-	],
-};
 
-schemas[validationKeys.TEST_LAUNCHER_INTERACTIVE] = {
-	'type': 'object',
-	'required': ['username', 'password', 'orgId', 'deviceId', 'appConfigId'],
-	'properties': {
-		'username': {'type': 'string'},
-		'password': {'type': 'string'},
-		'orgId': {'type': 'string'},
+		},
 		'appConfigId': {'type': 'string'},
 		'deviceId': {'type': 'string'},
 	},
 };
 
-schemas[validationKeys.SESSION_BOOTSTRAP_AUTOMATED] = {
-	'type': 'object',
-	'required': ['sessionToken'],
-	'properties': {
-		'sessionToken': {
-			'type': 'string',
-			'minLength': 1,
-		},
-	},
-};
-
-schemas[validationKeys.SESSION_BOOTSTRAP_INTERACTIVE] = {
+schemas[validationKeys.SESSION_BOOTSTRAP_TOKEN] = {
 	'type': 'object',
-	'required': ['sessionToken', 'appConfigId'],
+	'required': ['tokenId'],
 	'properties': {
-		'sessionToken': {
-			'type': 'string',
-			'minLength': 1,
-		},
-		'appConfigId': {
-			'type': 'string',
-			'minLength': 1,
-		},
+		'tokenId': {'type': 'string'},
+		'tokenPassword': {'type': 'string'},
 	},
 };
 
@@ -404,14 +367,17 @@ schemas[validationKeys.CONFIGURE] = {
 		'defaultTimeout': {'type': 'number'},
 		'logLevel': {'enum': ['silent', 'normal', 'verbose', 'debug', 'silly']},
 		'orgId': {'type': 'string'},
-		'password': {'type': 'string'},
 		'repl': {'type': 'boolean'},
 		'timestamp': {'type': 'string'},
-		'testPackId': {'type': ['number', 'string']},
-		'tokenKey': {'type': 'string'},
-		'tokenId': {'type': 'string'},
 		'tokenPassword': {'type': 'string'},
-		'username': {'type': 'string'},
+		'tokenId': {'type': 'string'},
+		'preset': {
+			'type': 'array',
+			'items': {'type': 'string'},
+		},
+		'presets': {'type': 'object'},
+		'screenshotDir': {'type': 'string'},
+		'includeChangelist': {'type': 'boolean'},
 	},
 };
 
@@ -440,6 +406,40 @@ schemas[validationKeys.DIRECTIONS] = {
 	'enum': [DIRECTIONS.UP, DIRECTIONS.DOWN, DIRECTIONS.LEFT, DIRECTIONS.RIGHT],
 };
 
+schemas[validationKeys.CSS_PROPS] = {
+	'schemaId': validationKeys.CSS_PROPS,
+	'type': 'array',
+	'minItems': 1,
+	'items': {
+		'type': 'string',
+		'minLength': 1,
+	},
+};
+
+schemas[validationKeys.ELEMENT_HANDLE] = {
+	'schemaId': validationKeys.ELEMENT_HANDLE,
+	'oneOf': [
+		{'type': 'boolean'},
+		{
+			'type': 'object',
+			'properties': {
+				'multiple': {
+					'type': 'boolean',
+				},
+			},
+		},
+	],
+};
+
+schemas[validationKeys.ELEMENT_ATTRIBUTES] = {
+	'schemaId': validationKeys.ELEMENT_ATTRIBUTES,
+	'type': 'array',
+	'items': {
+		'type': 'string',
+		'minLength': 1,
+	},
+};
+
 Object.freeze(schemas);
 
 module.exports = schemas;

package/lib/validation/validators.js

@@ -85,8 +85,27 @@ function prettifyJsonSchemaErrors(validate) {
 	if (validate.schema.schemaId === validationKeys.ELEMENT_PROPS) {
 		errors = prettifyElementPropsErrors(validate);
 	} else if (validate.schema.schemaId === validationKeys.CONFIGURE) {
-		// example: Invalid input provided for configuration object. 'disallowCrashReports' should be boolean.
-		errors = validate.errors.map(i => `'${i.dataPath.slice(1)}' ${i.message}.`);
+		errors = validate.errors.map(i => {
+			if (i.keyword === 'additionalProperties') {
+				// example: Invalid input provided for configuration object. It should NOT have additional properties: 'screenshotDir'
+				return `It ${i.message}: '${i.params.additionalProperty}'`;
+			}
+
+			// example: Invalid input provided for configuration object. 'disallowCrashReports' should be boolean.
+			return `'${i.dataPath.slice(1)}' ${i.message}.`;
+		});
+	} else if (
+		[validationKeys.ELEMENT_ATTRIBUTES, validationKeys.CSS_PROPS].includes(validate.schema.schemaId)
+	) {
+		errors = validate.errors.map(i => {
+			if (!i.dataPath) {
+				return i.message;
+			}
+
+			// Example:
+			// Element attributes item at [1] index should be string
+			return `item at ${i.dataPath} index ${i.message}`;
+		});
 	} else if (validate.schema.schemaId === validationKeys.ELEMENT_SELECTOR) {
 		errors = prettifyElementSelectorsErrors(validate);
 	} else {
@@ -94,6 +113,9 @@ function prettifyJsonSchemaErrors(validate) {
 			if (err.keyword === 'enum') {
 				return `${err.message}: "${err.params.allowedValues.join('", "')}"`; // -> ...of the allowed values: "all", "currentUrl"
 			}
+			if (err.dataPath) {
+				return err.dataPath + ' ' + err.message;
+			}
 
 			return err.message;
 		});
@@ -226,7 +248,7 @@ const validateRepoProps = ({props, data, text}) => {
 
 	if (repoProps.length) {
 		throwError(
-			text + ' ' + (selector.video ? invalidVideoInheredProps : invalidInheredProps)(repoProps.join(', '))
+			text + ' ' + (selector.video ? invalidVideoInheredProps : invalidInheredProps)(repoProps.join(', ')),
 		);
 	}
 

package/lib/validation/validatorsMap.js

@@ -35,9 +35,6 @@ const validatorsMap = {
 	[validationKeys.ELEMENT_SELECTOR]: (value, text) => {
 		return validators.validateJsonSchema(validationKeys.ELEMENT_SELECTOR, value, text);
 	},
-	[validationKeys.START_TEST_PACK]: (value, text) => {
-		return validators.validateJsonSchema(validationKeys.START_TEST_PACK, value, text);
-	},
 	[validationKeys.OPEN_SESSION]: (value, text) => {
 		return validators.validateJsonSchema(validationKeys.OPEN_SESSION, value, text);
 	},
@@ -66,20 +63,14 @@ const validatorsMap = {
 	[validationKeys.RESPONSE_MATCHES]: (value, text) => {
 		return validators.validateJsonSchema(validationKeys.RESPONSE_MATCHES, value, text);
 	},
-	[validationKeys.TEST_LAUNCHER_AUTOMATED]: (value, text) => {
-		return validators.validateJsonSchema(validationKeys.TEST_LAUNCHER_AUTOMATED, value, text);
-	},
-	[validationKeys.TEST_LAUNCHER_INTERACTIVE]: (value, text) => {
-		return validators.validateJsonSchema(validationKeys.TEST_LAUNCHER_INTERACTIVE, value, text);
-	},
 	[validationKeys.TEST_LAUNCHER_TEST_COMMAND]: (value, text) => {
 		return validators.validateNonEmptyArrayOfStrings(value, text);
 	},
-	[validationKeys.SESSION_BOOTSTRAP_AUTOMATED]: (value, text) => {
-		return validators.validateJsonSchema(validationKeys.SESSION_BOOTSTRAP_AUTOMATED, value, text);
+	[validationKeys.TEST_LAUNCHER_TOKEN]: (value, text) => {
+		return validators.validateJsonSchema(validationKeys.TEST_LAUNCHER_TOKEN, value, text);
 	},
-	[validationKeys.SESSION_BOOTSTRAP_INTERACTIVE]: (value, text) => {
-		return validators.validateJsonSchema(validationKeys.SESSION_BOOTSTRAP_INTERACTIVE, value, text);
+	[validationKeys.SESSION_BOOTSTRAP_TOKEN]: (value, text) => {
+		return validators.validateJsonSchema(validationKeys.SESSION_BOOTSTRAP_TOKEN, value, text);
 	},
 	[validationKeys.UNTIL_CONDITION_CHAIN]: value => {
 		return validators.validateUntilConditionChain(value);
@@ -96,6 +87,15 @@ const validatorsMap = {
 	[validationKeys.DIRECTIONS]: (value, text) => {
 		return validators.validateJsonSchema(validationKeys.DIRECTIONS, value, text);
 	},
+	[validationKeys.CSS_PROPS]: (value, text) => {
+		return validators.validateJsonSchema(validationKeys.CSS_PROPS, value, text);
+	},
+	[validationKeys.ELEMENT_HANDLE]: (value, text) => {
+		return validators.validateJsonSchema(validationKeys.ELEMENT_HANDLE, value, text);
+	},
+	[validationKeys.ELEMENT_ATTRIBUTES]: (value, text) => {
+		return validators.validateJsonSchema(validationKeys.ELEMENT_ATTRIBUTES, value, text);
+	},
 };
 
 Object.freeze(validatorsMap);