chrome - selenium webdriver java

Cómo funciona el método isDisplayed() de Selenium WebDriver

Question

Actualmente tengo una gran cantidad de circunstancias en las que necesito verificar que una página (junto con todos sus elementos) se muestran correctamente. El método isDisplayed() de WebElement parece ser una forma lógica de hacerlo, sin embargo, me gustaría entender con precisión qué está haciendo este método para determinar si un elemento se muestra o no. El javadoc no arroja ninguna luz sobre el funcionamiento interno del método y otra información en la web parece ser escasa en el mejor de los casos.

Si alguien pudiera proporcionar una descripción detallada de cómo funciona este método, estaría muy agradecido.

Answer 1

Confiaría en Selenium para determinar si se muestra un elemento o no. Si no funciona, puede generar un error y / o solucionar cualquier problema que vea y proporcionar un parche.

Esto es lo que hace el método (Tomado del código fuente actual de Selenium ):

/**
* Determines whether an element is what a user would call "shown". This means
* that the element is shown in the viewport of the browser, and only has
* height and width greater than 0px, and that its visibility is not "hidden"
* and its display property is not "none".
* Options and Optgroup elements are treated as special cases: they are
* considered shown iff they have a enclosing select element that is shown.
*
* @param {!Element} elem The element to consider.
* @param {boolean=} opt_ignoreOpacity Whether to ignore the element''s opacity
* when determining whether it is shown; defaults to false.
* @return {boolean} Whether or not the element is visible.
*/
bot.dom.isShown = function(elem, opt_ignoreOpacity) {
if (!bot.dom.isElement(elem)) {
throw new Error(''Argument to isShown must be of type Element'');
}
// Option or optgroup is shown iff enclosing select is shown (ignoring the
// select''s opacity).
if (bot.dom.isElement(elem, goog.dom.TagName.OPTION) ||
bot.dom.isElement(elem, goog.dom.TagName.OPTGROUP)) {
var select = /**@type {Element}*/ (goog.dom.getAncestor(elem, function(e) {
return bot.dom.isElement(e, goog.dom.TagName.SELECT);
}));
return !!select && bot.dom.isShown(select, /*ignoreOpacity=*/true);
}
// Image map elements are shown if image that uses it is shown, and
// the area of the element is positive.
var imageMap = bot.dom.maybeFindImageMap_(elem);
if (imageMap) {
return !!imageMap.image &&
imageMap.rect.width > 0 && imageMap.rect.height > 0 &&
bot.dom.isShown(imageMap.image, opt_ignoreOpacity);
}
// Any hidden input is not shown.
if (bot.dom.isElement(elem, goog.dom.TagName.INPUT) &&
elem.type.toLowerCase() == ''hidden'') {
return false;
}
// Any NOSCRIPT element is not shown.
if (bot.dom.isElement(elem, goog.dom.TagName.NOSCRIPT)) {
return false;
}
// Any element with hidden visibility is not shown.
if (bot.dom.getEffectiveStyle(elem, ''visibility'') == ''hidden'') {
return false;
}
// Any element with a display style equal to ''none'' or that has an ancestor
// with display style equal to ''none'' is not shown.
function displayed(e) {
if (bot.dom.getEffectiveStyle(e, ''display'') == ''none'') {
return false;
}
var parent = bot.dom.getParentElement(e);
return !parent || displayed(parent);
}
if (!displayed(elem)) {
return false;
}
// Any transparent element is not shown.
if (!opt_ignoreOpacity && bot.dom.getOpacity(elem) == 0) {
return false;
}
// Any element with the hidden attribute or has an ancestor with the hidden
// attribute is not shown
function isHidden(e) {
//IE does not support hidden attribute yet
if (goog.userAgent.IE) {
return true;
}
if (e.hasAttribute) {
if (e.hasAttribute(''hidden'')){
return false;
}
} else {
return true;
}
var parent = bot.dom.getParentElement(e);
return !parent || isHidden(parent);
}
if (!isHidden(elem)) {
return false;
}
// Any element without positive size dimensions is not shown.
function positiveSize(e) {
var rect = bot.dom.getClientRect(e);
if (rect.height > 0 && rect.width > 0) {
return true;
}
// A vertical or horizontal SVG Path element will report zero width or
// height but is "shown" if it has a positive stroke-width.
if (bot.dom.isElement(e, ''PATH'') && (rect.height > 0 || rect.width > 0)) {
var strokeWidth = bot.dom.getEffectiveStyle(e, ''stroke-width'');
return !!strokeWidth && (parseInt(strokeWidth, 10) > 0);
}
// Zero-sized elements should still be considered to have positive size
// if they have a child element or text node with positive size, unless
// the element has an ''overflow'' style of ''hidden''.
return bot.dom.getEffectiveStyle(e, ''overflow'') != ''hidden'' &&
goog.array.some(e.childNodes, function(n) {
return n.nodeType == goog.dom.NodeType.TEXT ||
(bot.dom.isElement(n) && positiveSize(n));
});
}
if (!positiveSize(elem)) {
return false;
}
// Elements that are hidden by overflow are not shown.
if (bot.dom.getOverflowState(elem) == bot.dom.OverflowState.HIDDEN) {
return false;
}

No estoy seguro de que realmente necesite más explicación, los comentarios son bastante claros. Avíseme si desea agregar más información.

Answer 2

WebDriver tiene su propia especificación W3C .

La sección sobre determinar la visibilidad es lo que buscas.

Me gustaría advertir que decir algo "se muestra" es un término tan amplio, y por lo tanto hay muchos escenarios para ello. Por lo tanto, puede haber situaciones en las que WebDriver no tenga en cuenta.

Por lo tanto, es importante, vital de hecho, recordar que algo que se "muestra" o "visible" tiene muchos significados . (De la misma forma en que una página se carga por completo , también tiene muchos significados).

También recuerde que Selenium es completamente de código abierto. No hay nada que le impida obtener un nuevo checkout del repositorio e inspeccionarlo localmente.