Référence de l'API

$browser.actions().sendKeys("synthetic").perform();

Exemple 1: Pour cliquer, utilisez le code suivant:

const element = await $browser.waitForAndFindElement(by, timeout);
$browser.actions().move({origin: element}).press().release().perform();

Exemple 2: Pour placer la souris sur un élément de navigateur, utilisez le code suivant:

const element = await $browser.waitForAndFindElement(by, timeout);
$browser.actions().move({origin: element, duration: 2000}).perform();

Pour être compatible avec l'ancienne fonction mouseMove , utilisez la commande suivante:

$browser.actions().mouseMove(element).perform();

Exemple 3: Pour envoyer des clés, exécutez le code suivant:

await $browser.get("http://www.bing.com");
await $browser.actions().sendKeys("synthetic").perform();

$browser.addHeader(key: string, val: string): Promise<void>;

await $browser.addHeader(
  "User-Agent",
  "Mozilla/5.0 (iPhone; CPU OS 10_15_5 (Ergänzendes Update) like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.1.1 Mobile/14E304 Safari/605.1.15"
);

await $browser.get("https://www.yahoo.com/");
await $browser.takeScreenshot();

await $browser.addHeader(
  "User-Agent",
  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.16; rv:86.0) Gecko/20100101 Firefox/86.0"
);

await $browser.get("https://www.yahoo.com/");
await $browser.takeScreenshot();

$browser.addHeaders(headers: { [key: string]: string }): Promise<void>;

await $browser.addHeaders({
  key1: "val1",
  key2: "val2",
});

$browser.addHostnamesToDenylist(hostnameArr: string[]): Promise<void>

$browser.addHostnamesToBlacklist(hostnameArr: string[]): Promise<void>

await $browser.addHostnamesToDenylist(["*.css", "*.png"]);
await $browser.addHostnamesToAllowlist(["*"]);

$browser.addHostnamesToAllowlist(hostnameArr: string[]): Promise<void>

$browser.addHostnamesToWhitelist(hostnameArr: string[]): Promise<void>

await $browser.addHostnamesToDenylist(["*.css", "*.png"]);
await $browser.addHostnamesToAllowlist(["*"]);

$browser.addHostnameToDenylist(hostname: string): Promise<void>

$browser.addHostnameToBlacklist(hostname: string): Promise<void>

await $browser.addHostnameToDenylist(`*.css`);
await $browser.addHostnameToAllowlist(`*`);

$browser.addHostnameToAllowlist(hostname: string): Promise<void>

$browser.addHostnameToWhitelist(hostname: string): Promise<void>

await $browser.addHostnameToDenylist(`*.css`);
await $browser.addHostnameToAllowlist(`*`);

$browser.clearProxy(): Promise<void>;

$browser.deleteHeader(key: string): Promise<void>;

await $browser.addHeader('header1-xxx', 'abcd');
await $browser.addHeaders({
    key1: 'val1',
    key2: 'val2',
});
await $browser.deleteHeaders(['key1']);

await $browser.get(`http://localhost:${devport}/header-test`);
let userHeaders: Map<string, any>  = $browser.getHeaders();
console.log("User customized headers: ", [...userHeaders]);
expect(userHeaders.size).toEqual(2);

$browser.deleteHeaders: (header: string[]) => Promise<void>;

await $browser.addHeader('header1-xxx', 'abcd');
await $browser.addHeaders({
    key1: 'val1',
    key2: 'val2',
});
await $browser.deleteHeaders(['key1']);

await $browser.get(`http://localhost:${devport}/header-test`);
let userHeaders: Map<string, any>  = $browser.getHeaders();
console.log("User customized headers: ", [...userHeaders]);
expect(userHeaders.size).toEqual(2);

$browser.deleteHostnameFromDenylist(hostname: string): Promise<void>;

$browser.deleteHostnameFromBlacklist(hostname: string): Promise<void>;

$browser.deleteHostnameFromAllowlist(hostname: string): Promise<void>;

$browser.deleteHostnameFromWhitelist(hostname: string): Promise<void>;

$browser.deleteHostnamesFromDenylist(hostnameArr: string[]): Promise<void>

$browser.deleteHostnamesFromBlacklist(hostnameArr: string[]): Promise<void>

$browser.deleteHostnamesFromAllowlist(hostnameArr: string[]): Promise<void>

$browser.deleteHostnamesFromWhitelist(hostnameArr: string[]): Promise<void>

$browser.$$(selector);

Le fichier index.html est le suivant:

<ul id="menu">
  <li><a href="/">Home</a></li>
  <li><a href="/">Developer Guide</a></li>
  <li><a href="/">API</a></li>
  <li><a href="/">Contribute</a></li>
</ul>

Utilisez $$ pour rechercher les éléments comme suit:

test("should get text a menu link", async () => {
  const menu = (await $browser.$$("#menu"))[0];
  const li = await menu.$$("li");

  console.log(await li[2].$("a").getText()); // outputs: "API"
});

test("should get text a menu link - JS Function", async () => {
  const text = (
    await $browser.$$(function () {
      // Arrow function is not allowed here.
      return document.querySelectorAll("#menu"); // Element[]
    })
  )[0];

  const li3Text = await (await text.$$("li"))[2].$("a").getText();
  console.log(li3Text); // outputs: "API"
});

$browser.$(selector): WebElementPromise;

Le fichier index.html est le suivant:

<ul id="menu">
  <li><a href="/">Home</a></li>
  <li><a href="/">Developer Guide</a></li>
  <li><a href="/">API</a></li>
  <li><a href="/">Contribute</a></li>
</ul>

Utilisez $ pour rechercher l'élément comme suit:

test("should get text a menu link", async () => {
  const text = await $browser.$("#menu").$$("li");
  console.log(await text[2].$("a").getText()); // outputs: "API"
});

test("should get text a menu link - JS Function", async () => {
  const text = await $browser.$(function () {
      // Arrow function is not allowed here.
      return document.querySelector("#menu"); // Element
    }).$$("li");

  console.log(text.$$("li")[2].$("a").getText()); // outputs: "API"
});

$browser.execute(command) => Promise<T>

Promise<T> est une promesse qui sera résolue avec le résultat de la commande.

$browser.executeAsyncScript<T>(script: string|Function, ...var_args: any[]): Promise<T>;

Exemple 1: Pour effectuer une mise en veille synchronisée avec la fenêtre actuellement sélectionnée, utilisez les commandes comme illustré dans l'exemple suivant:

const start = new Date().getTime();
$browser.executeAsyncScript(
    "window.setTimeout(arguments[arguments.length - 1], 500);"
  ).then(function () {
    console.log("Elapsed time: " + (new Date().getTime() - start) + " ms");
  });

Exemple 2: Pour synchroniser un test avec une application Ajax, utilisez les commandes comme illustré dans l'exemple suivant:

const button = $browser.$("#compose-button");
button.click();
$browser.executeAsyncScript(
  "var callback = arguments[arguments.length - 1];" +
    "mailClient.getComposeWindowWidget().onload(callback);"
);
$browser.switchTo().frame("composeWidget");
$browser.$("#to").sendKeys("dog@example.com");

Exemple 3: Pour injecter XMLHttpRequest et attendre le résultat, utilisez les commandes suivantes. Dans cet exemple, le script d'injection est spécifié avec un littéral de fonction. Lorsque vous utilisez ce format, la fonction est convertie en chaîne pour l'injection. Par conséquent, la fonction ne doit pas faire référence à des symboles qui ne sont pas définis dans la portée de la page testée.

$browser.executeAsyncScript(function () {
    var callback = arguments[arguments.length - 1];
    var xhr = new XMLHttpRequest();
    xhr.open("GET", "/resource/data.json", true);
    xhr.onreadystatechange = function () {
      if (xhr.readyState == 4) {
        callback(xhr.responseText);
      }
    };
    xhr.send("");
  }).then(function (str) {
    console.log(JSON.parse(str)["food"]);
  });

$browser.executeScript<T>(script: string|Function, ...var_args: any[]): Promise<T>;

$browser.findElement(locator: Locator): WebElementPromise;

Vous ne devez pas utiliser cette fonction pour tester si un élément est présent sur la page. Vous devez plutôt utiliser findElements :

$browser.findElements($driver.By.id("foo"))
  .then((found) => console.log("Element found? %s", !!found.length));

Vous pouvez définir les critères de recherche d'un élément en utilisant l'une des fabriques de l'espace de nom webdriver.By ou en tant qu'objet webdriver.By.Hash de courte durée. Par exemple, les deux instructions suivantes sont équivalentes:

var e1 = $browser.findElement($driver.By.id("foo"));
var e2 = $browser.findElement({ id: "foo" });

Vous pouvez également fournir une fonction de localisation personnalisée, qui prend cette instance en entrée et renvoie un WebElement, ou une promesse qui sera résolue avec un WebElement. Si la promesse renvoyée aboutit à un tableau de valeurs de type ` WebElements, `, ` WebDriver ` utilise le premier élément. Par exemple, pour trouver le premier lien visible sur une page, vous pouvez utiliser les commandes suivantes:

var link = $browser.findElement(firstVisibleLink);

function firstVisibleLink(driver) {
  var links = driver.findElements(By.tagName("a"));
  return promise.filter(links, function (link) {
    return link.isDisplayed();
  });
}

$browser.findElements(locator: Locator): Promise<WebElement[]>;

$browser.generateTOTPToken(key: string, options?: TOTPOptions): string;

Exemple 1: Pour générer un jeton TOTP et vous connecter avec l'authentification à deux facteurs dans le test Script de navigateur:

await $browser.waitForAndFindElement($driver.By.id("password"), 15000);

let totp_token = $browser.generateTOTPToken($secure.totpKey);

await $browser.findElement($driver.By.id("password")).then((element) => {
  return element.clear().then(() => {
    return element.sendKeys(totp_token);
  });
});

Exemple 2: Pour générer un jeton TOTP dans le test de script SIDE Selenium :

{
  "id": "ec51296b-4d16-4167-ac83-ba87f89cc0c7",
  "comment": "Generate a TOTP token from a TOTP key",
  "command": "executeScript",
  "target": "return $browser.generateTOTPToken($secure.totpKey);",
  "targets": [],
  "value": "totpToken"
}

$browser.get(url: string): Promise<void>;

$browser.getAllWindowHandles(): Promise<string[]>;

$browser.getCapabilities(): Promise<Capabilities>;

$browser.getCurrentUrl(): Promise<string>;

$browser.getHeaders(): Map<string, any>;

await $browser.addHeader('header1-xxx', 'abcd');
await $browser.addHeaders({
    key1: 'val1',
    key2: 'val2',
});
await $browser.deleteHeaders(['key1']);

await $browser.get(`http://localhost:${devport}/header-test`);
let userHeaders: Map<string, any>  = $browser.getHeaders();
console.log("User customized headers: ", [...userHeaders]);
expect(userHeaders.size).toEqual(2);

$browser.getPageSource(): Promise<string>;

$browser.getProxy(): FFProxyConfig | CProxyConfig;

Cette méthode API peut également être appelée via $network l'objet :

$network.getProxy(): FFProxyConfig | CProxyConfig;

/**
 * Firefox extension - An object encapsulating a complete proxy configuration
 * https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/proxy/settings
 */
export interface FFProxyConfig {
  proxyType?: FFProxyType,
  http?: string;
  ssl?: string,
  ftp?: string;
  autoConfigUrl?: string,
  autoLogin?: boolean,
  httpProxyAll?: boolean,
  passthrough?: string,
  proxyDNS?: boolean,
  socks?: string,
  socksVersion?: number,
}

/**
 * Chrome extension - An object encapsulating a complete proxy configuration
 * https://developer.chrome.com/docs/extensions/reference/proxy/#type-ProxyConfig
 */
export interface CProxyConfig {
  mode: CProxyType,
  rules?: {
    bypassList?: string[],
    fallbackProxy?: ProxyServer,
    proxyForFtp?: ProxyServer,
    proxyForHttp?: ProxyServer,
    proxyForHttps?: ProxyServer,
    singleProxy?: ProxyServer,
  },
  pacScript?: {
    data?: string,
    mandatory?: boolean,
    url?: string,
  },
};

$browser.getSession(): Promise<Session>;

$browser.getTitle(): Promise<string>;

$browser.getWindowHandle(): Promise<string>;

$browser.manage(): Options;

Les options fournissent des méthodes de gestion de l'état du navigateur et du pilote.

export interface ILocation {
  x: number;
  y: number;
}

export interface ISize {
  width: number;
  height: number;
}

export interface IRectangle {
  x: number;
  y: number;
  width: number;
  height: number;
}

Interface permettant de gérer la fenêtre en cours.

let tm = await $browser.manage().getTimeouts();
console.log('current timeout', tm.implicit, tm.pageLoad, tm.script);

await $browser.manage().timeouts().pageLoadTimeout(119);
tm = await $browser.manage().getTimeouts();
expect(tm.pageLoad).toBe(119);
console.log('current timeout', tm.implicit, tm.pageLoad, tm.script);

await $browser.manage().timeouts().pageLoadTimeout(89);
tm = await $browser.manage().getTimeouts();
expect(tm.pageLoad).toBe(89);
console.log('current timeout', tm.implicit, tm.pageLoad, tm.script);

$browser.navigate(): Navigation;

Interface de navigation permettant d'aller et de venir dans l'historique du navigateur.

$browser.setAuthentication(authName: string, authPass: string): Promise<void>;

await $browser.setAuthentication(basicauthuser, password);
await $browser.get(`http://${httpserver}/basic/page1.html`)
.then(() => $browser.takeScreenshot());

$browser.setProxy(proxyURL: string | URL, noProxy?: string): Promise<void>;

Cette méthode API peut également être appelée via $network l'objet.

$network.setProxy(proxyURL: string | URL, noProxy?: string): Promise<void>

$browser.setProxyAdvanced(proxyConfig: CProxyConfig | FFProxyConfig, authName?: string, authPass?: string): Promise<void>;

Cette méthode API peut également être appelée via $network l'objet.

$network.setProxyAdvanced(proxyConfig: CProxyConfig | FFProxyConfig, authName?: string, authPass?: string): Promise<void>;

async function testProxyAdvanced() {
  await $browser.clearProxy();
  var ffconfig = {
    proxyType: "manual",
    //proxyType: "autoConfig",
    http: proxy_4,
    ssl: proxy_4,
    ftp: proxy_4,
    autoConfigUrl: pacfile,
    passthrough: noproxy,
    autoLogin: true,
  }

  var pxyserver = {
    host: httpserver,
    port: 8088,
    scheme: "http",
  }

  var cconfig = {
    mode: "fixed_servers",
    rules: {
      bypassList: noproxy.split(','),
      fallbackProxy: {
        host: "my-proxy-server.us.ibm.com",
        port: 8080,
      },
      proxyForFtp: pxyserver,
      proxyForHttp: pxyserver,
      proxyForHttps: pxyserver,
    },
    pacScript: {
      url: pacfile,
    },
  }

  var bname = null;
  await $browser.getCapabilities().then(cap=> {
    bname = cap.getBrowserName();
   });

  var config = (bname == 'chrome') ? cconfig : ffconfig;

  await $browser.setProxyAdvanced(config, proxyuser, password);
  await $browser.get(`http://${httpserver}/demo/page2.html`)
    .then(() => $browser.takeScreenshot());
}

$browser.setProxyAuthentication(authName: string, authPass: string): Promise<void>;

async function testProxyAuthentication() {
  await $browser.clearProxy();
  await $browser.setProxy(proxy_3, noproxy);
  await $browser.setProxyAuthentication(proxyuser, password);
  await $browser.get(`http://${httpserver}/demo/page2.html`)
    .then(() => $browser.takeScreenshot());
}

$browser.setProxyForHttp(proxyURL: string | URL, noProxy?: string): Promise<void>

Cette méthode API peut également être appelée via $network l'objet.

$network.setProxyForHttp(proxyURL: string | URL, noProxy?: string): Promise<void>

let website;
let proxyServer = "proxyHost:proxyPort";

console.log(">>>>>>>>>>>>>>>>>>>", "Clear proxy configuration");
await $network.clearProxy();
console.log(">>>>>>>>>>>>>>>>>>>", "Set proxy configuration for HTTP request");
await $network.setProxyForHttp(proxyServer);
website = await accessWebSite();
checkHostname("www.google.com.hk", website)

$browser.setProxyForHttps(proxyURL: string | URL, noProxy?: string): Promise<void>;

Cette méthode API peut également être appelée via $network l'objet.

$network.setProxyForHttps(proxyURL: string | URL, noProxy?: string): Promise<void>;

let website;
let sslProxyServer = "username:password@proxyHost:proxyPort";

console.log(">>>>>>>>>>>>>>>>>>>", "Clear proxy configuration");
await $network.clearProxy();
console.log(">>>>>>>>>>>>>>>>>>>", "Set proxy configuration for HTTPS request");
let testURL = new URL("http://" + sslProxyServer);
await $network.setProxyForHttps(testURL);
website = await accessWebSite();
checkHostname("www.google.com", website);

$browser.setProxyPAC(pacScriptURL: string, noProxy?: string, authMap?: Map<string, any>): Promise<void>;

const httpserver = '<DemoServerIP>';
const noproxy = "localhost,google.com,192.168.1.0/24";
const pacfile = `http://${httpserver}/pacfile`;
const authmap = new Map([
  [ httpserver, {username: "proxyuser", password: "passw0rd"} ],
  [ "httpserver2", {username: "user1", password: "passw0rd"} ],
])

async function testProxyPAC() {
  await $browser.clearProxy();
  await $browser.setProxyPAC(pacfile, noproxy, authmap);
  await $browser
    .get(`http://${httpserver}/demo/page2.html`)
    .then(() => $browser.takeScreenshot());
}

$browser.sleep(ms: number): Promise<void>;

await $browser.get("https://www.yahoo.com/");
await $browser.sleep(3 * 1000);
await $browser.takeScreenshot();

$browser.switchTo(): TargetLocator;

Interface permettant de modifier la mise en évidence du pilote dans un autre cadre ou une autre fenêtre.

/**
 * samples of getting current window handle
 * switch to a new window
 * open new page in new tab
 */
console.log("Windows handle: ", await $browser.getWindowHandle(), "Current url: ", await $browser.getCurrentUrl());
console.log("switch to calendar tab");
let originalWindow = await $browser.getWindowHandle();
await $browser.switchTo().newWindow();

/**
 * navigate to www.timeanddate.com
 * assert page title by getTitle() api
 * assert page title by getPageSource() api
 */
console.log("Access time and date page");
await $browser.get("http://www.timeanddate.com");
let page = await $browser.getPageSource();
assert.isTrue(page.includes("<title>timeanddate.com</title>"));
console.log("Page title: ", await $browser.getTitle());

/**
 * switch back to original window
 * take screenshot
 */
await $browser.switchTo().window(originalWindow);
await $browser.takeScreenshot();

$browser.takeScreenshot(): Promise<string>;

$browser.wait(
    condition: WebElementCondition,
    opt_timeout?: number,
    opt_message?: string): WebElementPromise;

Exemple 1: Pour attendre jusqu'à 10 secondes qu'un élément soit présent sur la page, utilisez les commandes comme illustré dans l'exemple suivant:

async function example() {
  let button = await $browser.wait(
    $driver.until.elementLocated($driver.By.id("foo")),
    10000
  );
  await button.click();
}

Exemple 2: Pour attendre un élément et cliquer, utilisez les commandes comme illustré dans l'exemple suivant:

await $browser.wait(until.elementLocated(by), timeout);
const element = await $browser.findElement(by, timeout);
await $browser.wait(until.elementIsVisible(element), timeout, `${by} not visible`);
await $browser.wait(until.elementIsEnabled(element), timeout, `${by} not enabled`);
await element.click();

$browser.waitForAndFindElement(locator: Locator, timeout?: number) : WebElementPromise;

La fonction est similaire à la suivante:

const element = await $browser.wait(until.elementLocated(locator), timeout);
await $browser.wait(until.elementIsVisible(element), timeout);
return await $browser.findElement(locator);

$browser.waitForAndFindElement($driver.By.id("username"), 10000);

$browser.waitForPendingRequests(timeout?: number): Promise<void>;

La fonction est similaire à

let script = "return document.readyState === 'complete'";
await $browser.wait(() => {
    return $browser.executeScript(script);
}, timeout);