In goniometro, browser.isElementPresent vs element.isPresent vs element.isElementPresent

Question

In goniometro, ci sono, in fondo, 3 modi per controllare se un elemento è presente:

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

browser.isElementPresent(elm); 
elm.isPresent(); 
elm.isElementPresent(); 

sono queste opzioni equivalenti e intercambiabili, e quale dovrebbe essere generalmente preferito?

Answer 1

Tutte funzionano in modo simile con sottili differenze. Qui ci sono alcune differenze che ho trovato -

elm.isPresent() -

1. è un'estensione del ElementFinder e così waits for Angular a stabilirsi a pagina prima di eseguire qualsiasi azione.
2. Funziona quando elm è un element(locator) o ElementFinder e non ElementArrayFinder. Se vengono restituiti più elementi utilizzando lo locator specificato, il primo elemento viene controllato se è isEnabled() nel DOM. Non prende alcun parametro come input.
3. Funziona meglio con le pagine angolari e gli elementi angolari.
4. Prima preferenza da utilizzare ogni volta che è necessario trovare se è presente un elemento.

elm.isElementPresent(subLoc) - (Quando c'è un sub localizzatore per elm)

1. è un'estensione del ElementFinder e quindi attende angolare di stabilirsi a pagina prima di eseguire qualsiasi azione.
2. Utilizzato per verificare la presenza di elementi che sono sotto elementi di un genitore. È necessario un sub locator per il genitore elm come parametro. (unica differenza tra questa e elm.isPresent())
3. Funziona meglio con le pagine angolari e gli elementi angolari.
4. Prima preferenza da utilizzare ogni volta che è necessario verificare se è presente un subelemento di un genitore.

browser.isElementPresent(element || Locator) -

1. è un'implementazione di webdriver e quindi non aspettare angolare di stabilirsi.
2. prende un locator o un element come parametro e utilizza il primo risultato se più elementi si trovano utilizzando lo stesso localizzatore.
3. Ideale per le pagine non angolari.
4. Prima preferenza da utilizzare durante il test su pagine non angolari.

Tutti i controlli di cui sopra per la presenza di un elemento in DOM e restituiscono un risultato boolean. Sebbene le caratteristiche angolari e non angolari non influiscano sull'uso di questi metodi, ma c'è un vantaggio aggiunto quando il metodo attende per impostazione angolare di default e aiuta a evitare errori in caso di elemento simile angolare non trovato o eccezioni di riferimento agli elementi di stato, ecc ...

Answer 2

Non riesco a parlare a quale si preferisca, ma sono riuscito a trovare il codice sorgente ed esaminarlo.

Secondo i documenti, elm.isPresent() e elm.isElementPresent() sono equivalenti. Spero possa aiutare.

Protractor API Docs

C'è un collegamento a View code appena a destra del titolo.

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(); 
}; 

Answer 3

È possibile verificare se l'elemento è presente o non utilizzando la funzione isPresent.

Quindi, il codice sarebbe qualcosa di simile:

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

Here è la documentazione goniometro per la funzione isPresent.