@testplane/webdriverio
Version:
Next-gen browser and mobile automation test framework for Node.js
61 lines (60 loc) • 7.87 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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