@appium/base-driver
Version:
Base driver class for Appium drivers
219 lines • 10.2 kB
JavaScript
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ProtocolConverter = exports.COMMAND_URLS_CONFLICTS = void 0;
const lodash_1 = __importDefault(require("lodash"));
const support_1 = require("@appium/support");
const helpers_1 = require("../basedriver/helpers");
const constants_1 = require("../constants");
exports.COMMAND_URLS_CONFLICTS = [
{
commandNames: ['execute', 'executeAsync'],
jsonwpConverter: (url) => url.replace(/\/execute.*/, url.includes('async') ? '/execute_async' : '/execute'),
w3cConverter: (url) => url.replace(/\/execute.*/, url.includes('async') ? '/execute/async' : '/execute/sync'),
},
{
commandNames: ['getElementScreenshot'],
jsonwpConverter: (url) => url.replace(/\/element\/([^/]+)\/screenshot$/, '/screenshot/$1'),
w3cConverter: (url) => url.replace(/\/screenshot\/([^/]+)/, '/element/$1/screenshot'),
},
{
commandNames: ['getWindowHandles', 'getWindowHandle'],
jsonwpConverter(url) {
return url.endsWith('/window')
? url.replace(/\/window$/, '/window_handle')
: url.replace(/\/window\/handle(s?)$/, '/window_handle$1');
},
w3cConverter(url) {
return url.endsWith('/window_handle')
? url.replace(/\/window_handle$/, '/window')
: url.replace(/\/window_handles$/, '/window/handles');
},
},
{
commandNames: ['getProperty'],
jsonwpConverter: (w3cUrl) => {
const w3cPropertyRegex = /\/element\/([^/]+)\/property\/([^/]+)/;
return w3cUrl.replace(w3cPropertyRegex, '/element/$1/attribute/$2');
},
// Don't convert JSONWP URL to W3C. W3C accepts /attribute and /property
w3cConverter: (jsonwpUrl) => jsonwpUrl,
},
];
const { MJSONWP, W3C } = constants_1.PROTOCOLS;
const DEFAULT_LOG = support_1.logger.getLogger('Protocol Converter');
class ProtocolConverter {
proxyFunc;
_downstreamProtocol = null;
_log;
/**
* @param proxyFunc - Function to perform the actual proxy request
* @param log - Logger instance, or null to use the default
*/
constructor(proxyFunc, log = null) {
this.proxyFunc = proxyFunc;
this._log = log;
}
get log() {
return this._log ?? DEFAULT_LOG;
}
get downstreamProtocol() {
return this._downstreamProtocol;
}
set downstreamProtocol(value) {
this._downstreamProtocol = value;
}
/**
* Handle "crossing" endpoints for the case when upstream and downstream
* drivers operate different protocols.
*/
async convertAndProxy(commandName, url, method, body) {
if (!this.downstreamProtocol) {
return await this.proxyFunc(url, method, body);
}
// Same url, but different arguments
switch (commandName) {
case 'timeouts':
return await this.proxySetTimeouts(url, method, body);
case 'setWindow':
return await this.proxySetWindow(url, method, body);
case 'setValue':
return await this.proxySetValue(url, method, body);
case 'performActions':
return await this.proxyPerformActions(url, method, body);
case 'releaseActions':
return await this.proxyReleaseActions(url, method);
case 'setFrame':
return await this.proxySetFrame(url, method, body);
default:
break;
}
// Same arguments, but different URLs
for (const { commandNames, jsonwpConverter, w3cConverter } of exports.COMMAND_URLS_CONFLICTS) {
if (!commandNames.includes(commandName)) {
continue;
}
const rewrittenUrl = this.downstreamProtocol === MJSONWP ? jsonwpConverter(url) : w3cConverter(url);
if (rewrittenUrl === url) {
this.log.debug(`Did not know how to rewrite the original URL '${url}' for ${this.downstreamProtocol} protocol`);
break;
}
this.log.info(`Rewrote the original URL '${url}' to '${rewrittenUrl}' for ${this.downstreamProtocol} protocol`);
return await this.proxyFunc(rewrittenUrl, method, body);
}
// No matches found. Proceed normally
return await this.proxyFunc(url, method, body);
}
/**
* W3C /timeouts can take as many as 3 timeout types at once, MJSONWP /timeouts only takes one
* at a time. So if we're using W3C and proxying to MJSONWP and there's more than one timeout type
* provided in the request, we need to do 3 proxies and combine the result.
*/
getTimeoutRequestObjects(body) {
if (lodash_1.default.isNil(body)) {
return [];
}
const bodyObj = support_1.util.safeJsonParse(body) ?? {};
if (this.downstreamProtocol === W3C && lodash_1.default.has(bodyObj, 'ms') && lodash_1.default.has(bodyObj, 'type')) {
const typeToW3C = (x) => (x === 'page load' ? 'pageLoad' : x);
return [
{
[typeToW3C(bodyObj.type)]: bodyObj.ms,
},
];
}
if (this.downstreamProtocol === MJSONWP && (!lodash_1.default.has(bodyObj, 'ms') || !lodash_1.default.has(bodyObj, 'type'))) {
const typeToJSONWP = (x) => (x === 'pageLoad' ? 'page load' : x);
return lodash_1.default.toPairs(bodyObj)
// Only transform the entry if ms value is a valid positive float number
.filter((pair) => /^\d+(?:[.,]\d*?)?$/.test(`${pair[1]}`))
.map((pair) => ({
type: typeToJSONWP(pair[0]),
ms: pair[1],
}));
}
return [bodyObj];
}
/**
* Proxy an array of timeout objects and merge the result.
*/
async proxySetTimeouts(url, method, body) {
const timeoutRequestObjects = this.getTimeoutRequestObjects(body);
if (timeoutRequestObjects.length === 0) {
return await this.proxyFunc(url, method, body);
}
this.log.debug(`Will send the following request bodies to /timeouts: ${JSON.stringify(timeoutRequestObjects)}`);
let response;
let resBody;
for (const timeoutObj of timeoutRequestObjects) {
[response, resBody] = await this.proxyFunc(url, method, timeoutObj);
// If we got a non-MJSONWP response, return the result, nothing left to do
if (this.downstreamProtocol !== MJSONWP) {
return [response, resBody];
}
// If we got an error, return the error right away
if (response.statusCode >= 400) {
return [response, resBody];
}
// ...Otherwise, continue to the next timeouts call
}
return [response, resBody];
}
async proxySetWindow(url, method, body) {
const bodyObj = support_1.util.safeJsonParse(body);
if (lodash_1.default.isPlainObject(bodyObj)) {
const obj = bodyObj;
if (this.downstreamProtocol === W3C && lodash_1.default.has(bodyObj, 'name') && !lodash_1.default.has(bodyObj, 'handle')) {
this.log.debug(`Copied 'name' value '${obj.name}' to 'handle' as per W3C spec`);
return await this.proxyFunc(url, method, { ...obj, handle: obj.name });
}
if (this.downstreamProtocol === MJSONWP &&
lodash_1.default.has(bodyObj, 'handle') &&
!lodash_1.default.has(bodyObj, 'name')) {
this.log.debug(`Copied 'handle' value '${obj.handle}' to 'name' as per JSONWP spec`);
return await this.proxyFunc(url, method, { ...obj, name: obj.handle });
}
}
return await this.proxyFunc(url, method, body);
}
async proxySetValue(url, method, body) {
const bodyObj = support_1.util.safeJsonParse(body);
if (lodash_1.default.isPlainObject(bodyObj) && (support_1.util.hasValue(bodyObj?.text) || support_1.util.hasValue(bodyObj?.value))) {
let { text, value } = bodyObj;
if (support_1.util.hasValue(text) && !support_1.util.hasValue(value)) {
value = lodash_1.default.isString(text) ? [...text] : lodash_1.default.isArray(text) ? text : [];
this.log.debug(`Added 'value' property to 'setValue' request body`);
}
else if (!support_1.util.hasValue(text) && support_1.util.hasValue(value)) {
text = lodash_1.default.isArray(value) ? value.join('') : lodash_1.default.isString(value) ? value : '';
this.log.debug(`Added 'text' property to 'setValue' request body`);
}
return await this.proxyFunc(url, method, { ...bodyObj, text, value });
}
return await this.proxyFunc(url, method, body);
}
async proxySetFrame(url, method, body) {
const bodyObj = support_1.util.safeJsonParse(body);
if (lodash_1.default.has(bodyObj, 'id') && lodash_1.default.isPlainObject(bodyObj.id)) {
return await this.proxyFunc(url, method, {
...bodyObj,
id: (0, helpers_1.duplicateKeys)(bodyObj.id, constants_1.MJSONWP_ELEMENT_KEY, constants_1.W3C_ELEMENT_KEY),
});
}
return await this.proxyFunc(url, method, body);
}
async proxyPerformActions(url, method, body) {
const bodyObj = support_1.util.safeJsonParse(body);
if (lodash_1.default.isPlainObject(bodyObj)) {
return await this.proxyFunc(url, method, (0, helpers_1.duplicateKeys)(bodyObj, constants_1.MJSONWP_ELEMENT_KEY, constants_1.W3C_ELEMENT_KEY));
}
return await this.proxyFunc(url, method, body);
}
async proxyReleaseActions(url, method) {
return await this.proxyFunc(url, method);
}
}
exports.ProtocolConverter = ProtocolConverter;
//# sourceMappingURL=protocol-converter.js.map