web-dev-qa-db-fra.com

Dans le rapporteur, browser.isElementPresent vs element.isPresent vs element.isElementPresent

Dans le rapporteur, il y a, fondamentalement, 3 façons de vérifier si un élément est présent:

var Elm = element(by.id("myid"));

browser.isElementPresent(Elm);
Elm.isPresent();
Elm.isElementPresent();

Ces options sont-elles équivalentes et interchangeables, et laquelle devrait être généralement préférée?

javascriptseleniumselenium-webdriverprotractorend-to-end
25
alecxe

Tous fonctionnent de manière similaire avec des différences subtiles. Voici quelques différences que j'ai trouvées -

Elm.isPresent() -

  1. Est une extension de ElementFinder et donc attend Angular pour s'installer sur la page avant d'exécuter une action.
  2. Cela fonctionne lorsque Elm est une element(locator) ou ElementFinder et non ElementArrayFinder. Si plusieurs éléments sont retournés en utilisant le locator spécifié, le premier élément est vérifié s'il isEnabled() dans le DOM. Ne prend aucun paramètre en entrée.
  3. Fonctionne mieux avec Angular pages et Angular éléments.
  4. Première préférence à utiliser chaque fois qu'il est nécessaire de rechercher si un élément est présent.

Elm.isElementPresent(subLoc)Lorsqu'il existe un sous-localisateur pour Elm)

  1. Est une extension de ElementFinder et attend donc Angular pour s'installer sur la page avant d'exécuter une action.
  2. Utilisé pour vérifier la présence d'éléments qui sont des sous-éléments d'un parent. Il prend un sub locator Au parent Elm comme paramètre. (seule différence entre ceci et la Elm.isPresent())
  3. Fonctionne mieux avec Angular pages et Angular éléments.
  4. Première préférence à utiliser chaque fois qu'il est nécessaire de vérifier si un sous-élément d'un parent est présent.

--- (browser.isElementPresent(element || Locator) -

  1. Est une implémentation de webdriver et n'attend donc pas angular pour s'installer.
  2. Prend un locator ou un element comme paramètre et utilise le premier résultat si plusieurs éléments sont localisés en utilisant le même localisateur.
  3. Idéal pour les pages non angulaires.
  4. Première préférence à utiliser lors des tests sur des pages non angulaires.

Tout ce qui précède vérifie la présence d'un élément dans DOM et renvoie un résultat boolean. Bien que angular et les fonctionnalités non angulaires n'affectent pas l'utilisation de ces méthodes, mais il y a un avantage supplémentaire lorsque la méthode attend angular pour régler par défaut) et permet d'éviter les erreurs en cas de angular comme élément non trouvé ou état d'exceptions de référence d'élément, etc ...

34
Girish Sortur

Je ne peux pas dire lequel est préféré mais j'ai pu trouver le code source et l'examiner.

Selon les documents, Elm.isPresent() et Elm.isElementPresent() sont équivalents. J'espère que cela pourra aider.

Documents API du rapporteur

Il existe un lien vers View code juste à droite du titre.

browser.isElementPresent (Elm);

https://angular.github.io/protractor/#/api?view=webdriver.WebElement.prototype.isElementPresent

/**
 * Schedules a command to test if there is at least one descendant of this
 * element that matches the given search criteria.
 *
 * @param {!(webdriver.Locator|webdriver.By.Hash|Function)} locator The
 *     locator strategy to use when searching for the element.
 * @return {!webdriver.promise.Promise.<boolean>} A promise that will be
 *     resolved with whether an element could be located on the page.
 */
webdriver.WebElement.prototype.isElementPresent = function(locator) {
  return this.findElements(locator).then(function(result) {
    return !!result.length;
  });
};

Elm.isPresent ();

https://angular.github.io/protractor/#/api?view=ElementFinder.prototype.isPresent

/**
 * Determine whether the element is present on the page.
 *
 * @view
 * <span>{{person.name}}</span>
 *
 * @example
 * // Element exists.
 * expect(element(by.binding('person.name')).isPresent()).toBe(true);
 *
 * // Element not present.
 * expect(element(by.binding('notPresent')).isPresent()).toBe(false);
 *
 * @return {ElementFinder} which resolves to whether
 *     the element is present on the page.
 */
ElementFinder.prototype.isPresent = function() {
  return this.parentElementArrayFinder.getWebElements().then(function(arr) {
    if (arr.length === 0) {
      return false;
    }
    return arr[0].isEnabled().then(function() {
      return true; // is present, whether it is enabled or not
    }, function(err) {
      if (err.code == webdriver.error.ErrorCode.STALE_ELEMENT_REFERENCE) {
        return false;
      } else {
        throw err;
      }
    });
  }, function(err) {
    if (err.code == webdriver.error.ErrorCode.NO_SUCH_ELEMENT) {
      return false;
    } else {
      throw err;
    }
  });
};

Elm.isElementPresent ();

https://angular.github.io/protractor/#/api?view=ElementFinder.prototype.isElementPresent

/**
 * Same as ElementFinder.isPresent(), except this checks whether the element
 * identified by the subLocator is present, rather than the current element 
 * Finder. i.e. `element(by.css('#abc')).element(by.css('#def')).isPresent()` is
 * identical to `element(by.css('#abc')).isElementPresent(by.css('#def'))`.
 *
 * @see ElementFinder.isPresent
 *
 * @param {webdriver.Locator} subLocator Locator for element to look for.
 * @return {ElementFinder} which resolves to whether
 *     the subelement is present on the page.
 */
ElementFinder.prototype.isElementPresent = function(subLocator) {
  if (!subLocator) {
    throw new Error('SubLocator is not supplied as a parameter to ' + 
      '`isElementPresent(subLocator)`. You are probably looking for the ' + 
      'function `isPresent()`.');
  }
  return this.element(subLocator).isPresent();
};
3
JeffC