@testplane/webdriverio
Version:
Next-gen browser and mobile automation test framework for Node.js
61 lines (60 loc) • 7.84 kB
JavaScript
// src/protocol-stub.ts
import { capabilitiesEnvironmentDetector } from "@testplane/wdio-utils";
var NOOP = () => {
};
var ProtocolStub = class {
static async newSession(options) {
const capabilities = emulateSessionCapabilities(options.capabilities);
const browser = {
options,
capabilities,
requestedCapabilities: capabilities,
customCommands: [],
// internally used to transfer custom commands to the actual protocol instance
overwrittenCommands: [],
// internally used to transfer overwritten commands to the actual protocol instance
commandList: [],
getWindowHandle: NOOP,
on: NOOP,
off: NOOP,
addCommand: NOOP,
overwriteCommand: NOOP,
// eslint-disable-next-line @typescript-eslint/no-explicit-any
...capabilitiesEnvironmentDetector(capabilities, options._automationProtocol || "webdriver")
};
browser.addCommand = (...args) => browser.customCommands.push(args);
browser.overwriteCommand = (...args) => browser.overwrittenCommands.push(args);
return browser;
}
/**
* added just in case user wants to somehow reload webdriver or devtools session
* before it was started.
*/
static reloadSession() {
throw new Error("Protocol Stub: Make sure to start webdriver or devtools session before reloading it.");
}
static attachToSession(options, modifier) {
if (options || !modifier) {
throw new Error("You are trying to attach to a protocol stub, this should never occur, please file an issue.");
}
return modifier({
commandList: []
});
}
};
function emulateSessionCapabilities(caps) {
const capabilities = {};
Object.entries(caps).forEach(([key, value]) => {
const newKey = key.replace("appium:", "");
capabilities[newKey] = value;
});
const c = "alwaysMatch" in caps ? caps.alwaysMatch : caps;
if (c.browserName && c.browserName.toLowerCase() === "chrome") {
capabilities["goog:chromeOptions"] = {};
}
return capabilities;
}
export {
ProtocolStub as default
};
//# sourceMappingURL=data:application/json;base64,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