Dans le rapporteur, navigateur.isElementPresent vs élément.isPresent vs élément.isElementPresent

Au 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 équivalentes et interchangeables, et que l'on doit être généralement préféré?

InformationsquelleAutor alecxe | 2015-10-08
  1. 34

    Tous fonctionner d'une manière similaire, avec de subtiles différences. Voici quelques différences que j'ai trouvé -

    de l'orme.isPresent() -

    1. Est une extension de ElementFinder et donc attend Angulaire de s'installer sur la page avant l'exécution de toute action.
    2. Il fonctionne quand elm est un element(locator) ou ElementFinder et pas ElementArrayFinder. Si plusieurs éléments sont renvoyés à l'aide de la locator spécifié alors le premier élément est vérifié si il isEnabled() dans les DOM. Cela ne prend pas de paramètre en entrée.
    3. Qui fonctionne le mieux avec Angulaire des pages et des éléments Anguleux.
    4. De premier choix à utiliser chaque fois qu'il est nécessaire de trouver si un élément est présent.

    de l'orme.isElementPresent(subLoc) - (Quand il y a un sous locator elm)

    1. Est une extension de ElementFinder et donc attend Angulaire de s'installer sur la page avant l'exécution de toute action.
    2. Utilisé pour vérifier la présence des éléments qui sont des sous-éléments d'un parent. Il faut un sub locator pour le parent elm en tant que paramètre. (seule différence entre le présent et le elm.isPresent())
    3. Qui fonctionne le mieux avec Angulaire des pages et des éléments Anguleux.
    4. De premier choix à utiliser chaque fois qu'il est nécessaire de vérifier si un sous-élément de l'un des parents est présent.

    navigateur.isElementPresent(élément || Locator) -

    1. Est une implémentation de webdriver et donc ne pas attendre angulaire à régler.
    2. Prend un locator ou un element comme un paramètre et utilise le premier résultat si plusieurs éléments sont situées à l'aide de la même localisation.
    3. Utilisé au mieux avec les Non-Angulaire pages.
    4. De premier choix à utiliser lors de tests sur la non-angulaire pages.

    Toutes les vérifications ci-dessus pour la présence d'un élément dans le DOM et le retour d'un boolean résultat. Si angulaire et de la non-angulaire caractéristiques n'affecte pas l'utilisation de ces méthodes, mais il y a un avantage supplémentaire lorsque la méthode attend angulaire de régler par défaut et permet d'éviter les erreurs en cas de anguleux comme élément introuvable ou l'état de référence de l'élément exceptions, etc...

    • C'est le genre de réponse que j'espérais obtenir. Merci beaucoup! Je trouve que ces 3 moyens de contrôle de présence de source de confusion car il y a effectivement des différences entre les méthodes et c'est pas clair quelles sont les différences par simplement à la recherche de la façon dont les méthodes sont nommés. De Plus, les différences ne sont pas suffisamment étayées. Espérons que cette réponse est juste rempli le fossé et aiderait les autres à l'avenir.
    InformationsquelleAutor Girish Sortur
  2. 3

    Je ne peux pas parler de ce qui est préférée, mais j'ai été capable de trouver le code source et l'examiner.

    Selon les docs, elm.isPresent() et elm.isElementPresent() sont équivalentes. Espérons que cela aide.

    Le rapporteur de l'API Docs

    Il y a un lien View code juste à droite du titre.

    navigateur.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;
  });
};

    de l'orme.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;
    }
  });
};

    de l'orme.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();
};
    • Celui qui downvoted ce nous dire pourquoi, la réponse me semble bon.
    • Je pense que downvotes sont pour simplement copier-coller le code source sans expliquer quoi que ce soit.
    • N'ai pas downvoted mais je n'ai pas upvoted soit. Je pense que Michael a certainement raison sur le downvote raisons. Je vous remercie pour votre participation et à la recherche dans ce de toute façon!
    • Je n'ai expliquer que les deux sont équivalents... le reste, je pensais était assez explicite de la source. Ce sont comme 2 - 3-liner fonctions, à l'exclusion de l'erreur de code dans elm.isPresent(). hausse les épaules
    InformationsquelleAutor JeffC
  3. -3

    Vous pouvez vérifier si l'élément est présent ou non à l'aide de la isPresent fonction.

    Donc, votre code devrait être quelque chose comme:

    var myElement = element(by.css('.elementClass'));
expect(myElement.isPresent()).toBeFalsy();

    Ici est le rapporteur des docs pour le isPresent fonction.

    • Merci! C'est le problème - il y a en fait 3 façons de faire que rapporteur, et c'est ce que la question est à propos.
    InformationsquelleAutor