A4Q Selenium Tester Examen de práctica #2 — Preguntas y respuestas
Todas las preguntas de este examen de práctica, con la respuesta correcta marcada y una justificación escrita para cada opción a continuación — para leer y repasar, no una prueba cronometrada.
En Selenium 4, ¿cuál es la función principal de la interfaz WebDriver?
Define una API común e independiente del navegador que los drivers concretos (ChromeDriver, FirefoxDriver) implementan para controlar un navegador real.
Correcto — WebDriver es la interfaz; cada driver de navegador la implementa, de modo que el mismo código de prueba controla cualquier navegador compatible.
Renderiza la propia página web, sustituyendo al motor del navegador.
Incorrecto — WebDriver no renderiza páginas; lo hace el motor del navegador. WebDriver solo envía comandos al navegador.
Es un ejecutor de pruebas que descubre y ejecuta casos de prueba.
Incorrecto — ejecutar y reportar pruebas es tarea de un framework como JUnit, TestNG o pytest, no de WebDriver.
Es una biblioteca de aserciones para verificar los resultados esperados.
Incorrecto — las aserciones provienen del framework de pruebas o de una biblioteca de aserciones; WebDriver solo proporciona comandos de automatización del navegador.
WebDriver define una API independiente del navegador; una clase de driver específica del navegador la implementa y controla un navegador real.
¿Qué protocolo de comunicación usa Selenium 4 de forma predeterminada entre los bindings del cliente y el driver del navegador?
El protocolo W3C WebDriver.
Correcto — Selenium 4 usa exclusivamente el estándar W3C WebDriver, mejorando la estabilidad entre navegadores.
El antiguo JSON Wire Protocol.
Incorrecto — el JSON Wire Protocol se usaba en Selenium 3 y anteriores y se eliminó en Selenium 4.
FTP.
Incorrecto — FTP es un protocolo de transferencia de archivos y no tiene relación con la automatización del navegador.
SMTP.
Incorrecto — SMTP es un protocolo de correo electrónico; no interviene en el control de un navegador.
Selenium 4 está totalmente estandarizado en el protocolo W3C WebDriver; el antiguo JSON Wire Protocol fue eliminado.
¿Cuál es la diferencia entre driver.quit() y driver.close()?
close() cierra solo la ventana/pestaña actual del navegador, mientras que quit() finaliza toda la sesión de WebDriver y cierra todas las ventanas.
Correcto — esta es la distinción clave; use quit() en el teardown para liberar el proceso del driver.
Son idénticos; ambos finalizan la sesión.
Incorrecto — solo quit() finaliza la sesión. close() mantiene la sesión activa con las ventanas restantes.
quit() cierra solo la pestaña actual; close() finaliza toda la sesión.
Incorrecto — esto invierte los dos métodos.
close() borra las cookies; quit() recarga la página.
Incorrecto — ninguno de los métodos trata sobre cookies o recarga; ambos cierran ventanas/sesiones.
close() cierra la ventana actual; quit() finaliza toda la sesión y libera el driver.
¿Cuáles de los siguientes son comandos de navegación válidos de la interfaz WebDriver.Navigation? Seleccione DOS.
navigate().refresh()
Correcto — refresh() recarga la página actual y forma parte de la interfaz Navigation.
navigate().back()
Correcto — back() retrocede un paso en el historial del navegador y forma parte de la interfaz Navigation.
navigate().scroll()
Incorrecto — no existe scroll() en la interfaz Navigation; el desplazamiento se hace con Actions o JavaScript.
navigate().click()
Incorrecto — click() es un método de WebElement, no un comando de navegación.
navigate().back(), forward(), refresh() y to(url) pertenecen a la interfaz Navigation.
Una prueba abre un enlace que genera una segunda ventana del navegador. ¿Qué par de métodos permite enumerar las ventanas abiertas y cambiar el foco a la nueva?
getWindowHandles() y switchTo().window(handle)
Correcto — getWindowHandles() devuelve el conjunto de handles y switchTo().window() mueve el foco del driver a la ventana elegida.
getWindowHandle() y switchTo().frame(index)
Incorrecto — getWindowHandle() (singular) devuelve solo el handle actual, y frame() cambia a iframes, no a ventanas.
findElements() y click()
Incorrecto — estos localizan y hacen clic en elementos; no gestionan el foco de ventana.
navigate().to() y get()
Incorrecto — estos cargan una URL en la ventana actual y no cambian entre ventanas existentes.
getWindowHandles() devuelve todos los handles; switchTo().window(handle) cambia el foco.
Un tester ejecuta el siguiente código Java contra una página que tarda unos 3 segundos en renderizar el cuadro de búsqueda tras dispararse el evento 'load':
WebDriver driver = new ChromeDriver();
driver.get("https://shop.example.com");
driver.findElement(By.id("search")).sendKeys("laptop");
No hay configurada ninguna espera implícita ni explícita. ¿Cuál es el resultado MÁS probable?
Se lanza una NoSuchElementException porque findElement se ejecuta antes de que se renderice el cuadro de búsqueda.
Correcto — get() retorna en el evento load; el elemento aparece ~3 s después, así que sin espera la búsqueda falla de inmediato.
Selenium espera automáticamente hasta que aparece el elemento y luego escribe el texto.
Incorrecto — WebDriver no espera automáticamente; sin una espera configurada no sondea el elemento.
El texto se escribe correctamente porque get() se bloquea hasta que se carga todo el contenido asíncrono.
Incorrecto — get() se bloquea solo hasta el evento load, no hasta que termina el renderizado asíncrono.
Se lanza una TimeoutException tras el tiempo de espera predeterminado de 30 segundos.
Incorrecto — no hay espera configurada, por lo que no hay tiempo de sondeo; el fallo es una NoSuchElementException inmediata.
driver.get() se bloquea solo hasta el evento load, no hasta que aparezca el contenido asíncrono. Sin espera, findElement se ejecuta de inmediato, el elemento aún no está presente y se lanza una NoSuchElementException.
En Selenium 4, ¿cómo debe pasarse la configuración específica del navegador, como el modo headless o un directorio de descargas personalizado, al crear un driver?
Construyendo un objeto Options del navegador (p. ej. ChromeOptions) y pasándolo al constructor del driver.
Correcto — las clases Options son el mecanismo de Selenium 4 para capabilities y flags del navegador.
Instanciando la clase obsoleta DesiredCapabilities y pasándola directamente.
Incorrecto — DesiredCapabilities quedó obsoleta y se eliminó como argumento del constructor en Selenium 4; Options la reemplazó.
Editando el archivo de configuración del propio navegador en disco antes de la ejecución.
Incorrecto — esto es frágil y no es el enfoque admitido por WebDriver; Options ofrece una API programática y portable.
La configuración no se puede cambiar; el driver siempre usa los valores predeterminados del navegador.
Incorrecto — la configuración es totalmente compatible mediante Options; el driver no impone valores predeterminados.
Selenium 4 eliminó DesiredCapabilities; las clases Options del navegador (ChromeOptions, FirefoxOptions) son la forma admitida de configurar una sesión.
¿Qué afirmaciones sobre Selenium WebDriver son correctas? Seleccione DOS.
Controla un navegador real mediante un ejecutable driver específico del navegador (p. ej. chromedriver).
Correcto — cada navegador tiene un ejecutable driver al que se envían los comandos de WebDriver.
Puede ejecutar el navegador en modo headless para entornos de CI.
Correcto — el modo headless (mediante Options) se usa habitualmente en servidores sin pantalla.
Es una herramienta de grabar y reproducir que no requiere programación.
Incorrecto — eso describe a Selenium IDE; WebDriver es una API de programación.
Puede probar aplicaciones de escritorio nativas sin un navegador.
Incorrecto — WebDriver automatiza navegadores; las apps de escritorio nativas necesitan herramientas como WinAppDriver o Appium.
WebDriver controla un navegador real mediante el ejecutable driver del propio navegador y funciona headless; no es un IDE de grabar y reproducir.
Dado el HTML siguiente, ¿qué localizador selecciona de forma única el campo de correo electrónico?
<form id="signup"><input name="email" type="email" class="field"><input name="phone" type="tel" class="field"></form>
By.cssSelector("input[name='email']")
Correcto — el atributo name es único para el campo de correo, así que este selector CSS coincide exactamente con un elemento.
By.className("field")
Incorrecto — ambos inputs tienen la clase 'field', así que coincide con dos elementos y findElement devuelve el primero (el incorrecto).
By.id("email")
Incorrecto — no hay ningún elemento con id 'email'; el campo de correo solo tiene un atributo name.
By.tagName("input")
Incorrecto — hay dos elementos input, así que es ambiguo y devuelve la primera coincidencia.
Ambos inputs comparten la clase 'field', por lo que By.className es ambiguo. El atributo name 'email' es único.
Según las buenas prácticas de Selenium, ¿por qué suele preferirse By.id() frente a un XPath absoluto como /html/body/div[2]/form/input[1]?
Un id estable es único y resistente a los cambios de diseño, mientras que un XPath absoluto se rompe cuando cambia la estructura del DOM.
Correcto — las rutas absolutas son frágiles; un id estable sigue localizando el elemento tras reordenar el marcado.
El XPath absoluto no se puede usar en absoluto en Selenium 4.
Incorrecto — el XPath absoluto sigue funcionando; solo se desaconseja por ser frágil.
Los IDs siempre son más lentos de evaluar que XPath.
Incorrecto — suele ser al revés; las búsquedas por id son normalmente la estrategia de localización más rápida.
El XPath absoluto garantiza una coincidencia única, por lo que es la opción más fiable.
Incorrecto — puede ser único en un momento dado, pero es muy sensible a los cambios estructurales, lo que lo hace poco fiable con el tiempo.
Los IDs (cuando existen y son estables) son rápidos y robustos; el XPath absoluto se rompe cuando cambia la estructura del DOM.
¿Qué XPath selecciona el botón cuyo texto visible es exactamente 'Add to cart'?
<button class="btn primary">Add to cart</button>
//button[normalize-space(text())='Add to cart']
Correcto — coincide con el botón por su texto visible recortado, robusto frente a espacios iniciales/finales.
//button[@text='Add to cart']
Incorrecto — el botón no tiene un atributo 'text'; el texto visible no es un atributo en HTML.
//button[@class='Add to cart']
Incorrecto — coincide con el atributo class, cuyo valor es 'btn primary', no con el texto del botón.
//button#Add to cart
Incorrecto — '#' es sintaxis de id de CSS y no es válida dentro de una expresión XPath.
XPath text() con normalize-space coincide con el contenido de texto visible del elemento.
¿Qué selector CSS coincide con un enlace cuyo atributo href TERMINA en '.pdf'?
<a href="/files/report.pdf">Download report</a>
a[href$='.pdf']
Correcto — el operador $= coincide con valores de atributo que terminan con la cadena dada.
a[href^='.pdf']
Incorrecto — ^= coincide con valores que EMPIEZAN por la cadena; el href empieza por '/files', no por '.pdf'.
a[href='.pdf']
Incorrecto — = exige que todo el valor del atributo sea igual a '.pdf', lo que no ocurre.
a[href~='.pdf']
Incorrecto — ~= coincide con una palabra separada por espacios dentro del valor, lo que no aplica al final de una URL.
El selector de atributo CSS [attr$='value'] coincide cuando el valor del atributo termina con la subcadena dada.
¿Cuál es la diferencia práctica entre driver.findElement() y driver.findElements()?
findElement devuelve la primera coincidencia y lanza NoSuchElementException si no hay ninguna; findElements devuelve una lista (posiblemente vacía) sin lanzar excepción.
Correcto — findElements es la opción segura cuando un elemento puede estar ausente, ya que devuelve una lista vacía.
Ambos lanzan NoSuchElementException cuando no coincide ningún elemento.
Incorrecto — findElements no lanza; devuelve una lista vacía.
findElements devuelve solo el primer elemento coincidente.
Incorrecto — findElements devuelve todos los elementos coincidentes como lista; findElement devuelve solo el primero.
findElement solo puede usarse con By.id.
Incorrecto — findElement funciona con cualquier estrategia de localización By.
findElement lanza NoSuchElementException cuando no hay coincidencias; findElements devuelve una lista vacía.
¿Cuáles de los siguientes son ventajas de los selectores CSS frente a XPath en Selenium? Seleccione DOS.
Los selectores CSS suelen ser más rápidos de evaluar en la mayoría de motores de navegador.
Correcto — la evaluación nativa del motor CSS suele ser más rápida que XPath en la mayoría de navegadores.
La sintaxis CSS suele ser más concisa para coincidencias por id, clase y atributo.
Correcto — para búsquedas comunes CSS suele ser más corto y legible que el equivalente en XPath.
Los selectores CSS pueden navegar a un elemento padre o ancestro.
Incorrecto — CSS no puede seleccionar ancestros; solo XPath admite ejes padre/ancestro.
Los selectores CSS pueden localizar un elemento por su texto visible.
Incorrecto — CSS no puede coincidir con contenido de texto; XPath sí con text()/normalize-space().
Los selectores CSS suelen ser más rápidos en la mayoría de motores de navegador y más concisos en casos comunes; pero CSS no puede navegar a nodos padre/ancestro ni coincidir con texto visible.
Una fila de una tabla de datos debe localizarse por el texto de su segunda celda. ¿Qué XPath encuentra el <tr> que contiene un <td> con el texto 'Invoice #4521'?
<tr><td>2026-07-01</td><td>Invoice #4521</td></tr>
//tr[td[normalize-space()='Invoice #4521']]
Correcto — selecciona el tr que tiene un td hijo con el texto dado, devolviendo toda la fila.
//td[text()='Invoice #4521']
Incorrecto — devuelve la propia celda, no la fila padre solicitada.
//tr/td::parent[text()='Invoice #4521']
Incorrecto — 'td::parent' no es sintaxis de eje XPath válida; el eje parent se escribe parent::tr.
tr:has(td:contains('Invoice #4521'))
Incorrecto — :contains() no es un selector CSS estándar admitido por Selenium, y mezcla CSS con lo solicitado en XPath.
XPath puede seleccionar una fila ancestro desde una celda descendiente con el patrón //td[...]/parent::tr o //tr[td[...]].
Un equipo usa localizadores ligados a nombres de clase autogenerados como 'css-1x9k2f'. ¿Por qué es una mala estrategia de localización?
Los nombres de clase autogenerados cambian entre compilaciones, por lo que los localizadores quedan inválidos de forma impredecible.
Correcto — los nombres de clase con hash son volátiles; un data-testid o id estable es mucho más fiable.
Selenium no puede usar nombres de clase como localizadores en absoluto.
Incorrecto — Selenium admite plenamente localizadores por clase; el problema es la inestabilidad de estos nombres concretos.
Los localizadores por nombre de clase siempre son más lentos que los de id y causan timeouts.
Incorrecto — el problema central es la inestabilidad, no la velocidad; el rendimiento no es la causa del fallo.
Los nombres de clase no pueden contener dígitos, así que 'css-1x9k2f' es HTML inválido.
Incorrecto — los nombres de clase pueden contener dígitos; tales nombres son HTML válido, solo inestables.
Los nombres de clase autogenerados (de herramientas CSS-in-JS) cambian en cada compilación, por lo que los localizadores ligados a ellos se rompen de forma impredecible.
¿Cuál es la idea central del Page Object Model (POM)?
Cada página (o componente) se representa mediante una clase que encapsula sus localizadores e interacciones, manteniendo las pruebas libres de localizadores en crudo.
Correcto — esta separación de responsabilidades es la esencia de POM y mejora la mantenibilidad.
Almacena todos los datos de prueba en un único archivo JSON por página.
Incorrecto — eso describe las pruebas basadas en datos, no el Page Object Model.
Sustituye WebDriver por un motor de comparación de capturas de pantalla.
Incorrecto — POM es un patrón de diseño para organizar código, no una técnica de prueba visual.
Exige que cada prueba se escriba en sintaxis Gherkin.
Incorrecto — Gherkin es una notación BDD e independiente de POM.
POM encapsula los localizadores e interacciones de una página en una clase, separándolos de la lógica de la prueba.
En un Page Object bien diseñado, ¿dónde deben ubicarse normalmente las aserciones (verificación de resultados esperados)?
En los métodos de prueba; el Page Object expone acciones y getters pero deja la verificación a las pruebas.
Correcto — mantener las aserciones fuera de los page objects los hace reutilizables en muchas pruebas con distintas expectativas.
Dentro de cada método del Page Object, para que cada acción se autoverifique.
Incorrecto — incrustar aserciones acopla los page objects a expectativas concretas y perjudica la reutilización.
En la clase del driver de WebDriver.
Incorrecto — el driver es un controlador de navegador de bajo nivel y no es donde corresponde la verificación.
Las aserciones nunca son necesarias cuando se usa POM.
Incorrecto — las pruebas siguen necesitando aserciones; POM solo cambia dónde viven los localizadores, no si hay verificación.
Los Page Objects modelan el comportamiento de la página y devuelven estado; las aserciones van en los métodos de prueba, manteniendo reutilizables los page objects.
Cuando un método de Page Object realiza una acción que lleva al usuario a otra página, ¿cuál es un valor de retorno recomendado?
Una instancia del Page Object que representa la página de destino.
Correcto — devolver el siguiente page object favorece una API fluida y documenta la navegación en el código.
El código HTML en crudo de la nueva página como String.
Incorrecto — devolver HTML en crudo anula la abstracción que aporta POM y es difícil de manejar.
La propia instancia de WebDriver.
Incorrecto — exponer el driver filtra detalles de bajo nivel a las pruebas y socava la abstracción de página.
Siempre void; los métodos de página nunca deben devolver nada.
Incorrecto — aunque algunas acciones son void, los métodos de navegación se benefician de devolver el page object de destino.
Devolver el siguiente Page Object permite el encadenamiento fluido y modela explícitamente el flujo de navegación.
¿Cuáles de los siguientes son beneficios de usar el Page Object Model? Seleccione DOS.
Cuando cambia un localizador, se actualiza en un solo lugar en vez de en muchas pruebas.
Correcto — centralizar los localizadores es un beneficio principal de POM para la mantenibilidad.
Las pruebas se leen como acciones de negocio (p. ej. loginPage.loginAs(user)) en vez de llamadas a localizadores de bajo nivel.
Correcto — un código de prueba legible y de más alto nivel es una ventaja clave de encapsular páginas.
Elimina la necesidad de cualquier espera o sincronización.
Incorrecto — POM no aborda el tiempo; las esperas siguen siendo necesarias para contenido dinámico.
Hace que las pruebas se ejecuten en paralelo automáticamente.
Incorrecto — la ejecución en paralelo la configura el framework/ejecutor de pruebas, no la aporta POM.
POM centraliza los localizadores (un solo lugar que actualizar ante cambios de UI) y mejora la legibilidad/reutilización del código de prueba.
¿A qué se refiere el término 'Page Factory' en el contexto de los Page Objects de Selenium (Java)?
Una clase de soporte de Selenium que inicializa campos WebElement anotados con @FindBy en un page object.
Correcto — PageFactory.initElements() conecta los campos @FindBy de forma perezosa, un ayudante clásico de POM en los bindings de Java.
Un patrón de diseño para crear instancias del driver del navegador.
Incorrecto — eso describe una factoría de drivers; Page Factory inicializa los campos de elementos del page object.
Una herramienta que genera páginas HTML para pruebas.
Incorrecto — PageFactory no genera páginas; conecta localizadores con campos.
Una biblioteca de reportes para resultados de pruebas.
Incorrecto — los reportes no tienen relación con PageFactory, que trata de la inicialización de elementos.
PageFactory es una clase de soporte de Selenium que inicializa campos anotados con @FindBy mediante PageFactory.initElements().
Una suite de pruebas tiene un único page object gigante con 200 elementos y 80 métodos para toda la aplicación. Desde el punto de vista del diseño, ¿cuál es el problema principal?
Rompe el principio de responsabilidad única; cada página o componente debería tener su propio page object enfocado.
Correcto — un objeto todopoderoso es difícil de mantener; POM funciona mejor cuando las clases corresponden a páginas/componentes individuales.
Nada; un page object grande es el enfoque recomendado de POM.
Incorrecto — POM recomienda una clase por página/componente, no un único monolito.
WebDriver no puede manejar más de 100 elementos en una clase.
Incorrecto — no existe tal límite técnico; el problema es de diseño/mantenibilidad, no un tope de WebDriver.
Los page objects nunca deben contener más de un método.
Incorrecto — los page objects pueden tener muchos métodos; el problema es el alcance, no el número de métodos en sí.
Un único page object monolítico viola el modelo; cada página/componente debería ser su propia clase para mantenerse cohesiva y mantenible.
¿Cuál es la diferencia clave entre una espera implícita y una espera explícita en Selenium WebDriver?
Una espera implícita se aplica globalmente a cada búsqueda de elemento, mientras que una espera explícita espera una condición concreta sobre un elemento concreto.
Correcto — las esperas explícitas se basan en condiciones y son específicas; las implícitas fijan un timeout de sondeo general para todos los findElement.
Una espera implícita pausa la ejecución un número fijo de segundos siempre, como Thread.sleep.
Incorrecto — eso describe una pausa fija; una espera implícita solo espera hasta el timeout y retorna en cuanto encuentra el elemento.
Una espera explícita se aplica a todos los elementos y no puede apuntar a una condición.
Incorrecto — esto invierte los conceptos; las esperas explícitas sirven precisamente para apuntar a una condición concreta.
No hay diferencia; los dos términos son sinónimos.
Incorrecto — son mecanismos distintos con distinto alcance y comportamiento.
La espera implícita se aplica globalmente a todas las búsquedas de elementos; la explícita apunta a una condición concreta de un elemento concreto.
Un tester quiere esperar a que un spinner desaparezca y los resultados sean cliqueables. ¿Qué fragmento Java es el enfoque correcto de espera explícita en Selenium 4?
new WebDriverWait(driver, Duration.ofSeconds(10)).until(ExpectedConditions.elementToBeClickable(By.id("result")))
Correcto — Selenium 4 recibe un Duration y sondea hasta que se cumple la ExpectedCondition o expira el timeout.
Thread.sleep(10000); driver.findElement(By.id("result")).click();
Incorrecto — una pausa fija no es una espera explícita; malgasta tiempo cuando es rápido y aún falla cuando es lento.
driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10)); driver.findElement(By.id("result")).click();
Incorrecto — una espera implícita espera la presencia, no la posibilidad de clic, por lo que puede hacer clic en un elemento presente pero aún no interactuable.
driver.wait(10).click(By.id("result"));
Incorrecto — no existe tal API driver.wait(...).click() en Selenium; es inválido.
WebDriverWait con Duration y un método de ExpectedConditions (p. ej. elementToBeClickable) es la espera explícita idiomática en Selenium 4.
¿Por qué se desaconseja mezclar esperas implícitas y explícitas en la misma prueba?
Los dos mecanismos pueden combinarse, provocando tiempos de espera impredecibles e inesperadamente largos.
Correcto — la interacción entre el sondeo implícito y explícito no está definida y puede sumarse, por eso la guía oficial es evitar mezclarlos.
Selenium lanza un error en tiempo de compilación si se configuran ambas.
Incorrecto — no hay error de compilación; el código se ejecuta pero el tiempo se vuelve poco fiable.
Las esperas explícitas dejan de funcionar por completo una vez que se establece una espera implícita.
Incorrecto — las esperas explícitas siguen funcionando; el problema es el tiempo combinado impredecible, no un fallo total.
Porque las esperas implícitas no son compatibles con Selenium 4.
Incorrecto — las esperas implícitas siguen siendo compatibles; solo no se recomiendan junto con las explícitas.
Combinarlas puede producir tiempos de espera impredecibles y más largos de lo esperado porque los dos mecanismos interactúan.
¿Qué es un FluentWait y cómo extiende la espera explícita básica?
Una espera que permite fijar el timeout, el intervalo de sondeo y qué excepciones ignorar mientras se espera.
Correcto — FluentWait expone withTimeout, pollingEvery e ignoring, dando control fino sobre la espera.
Una espera que nunca expira y bloquea la prueba para siempre.
Incorrecto — FluentWait siempre tiene un timeout configurado; no bloquea indefinidamente.
Una espera aplicada automáticamente a todos los elementos sin código.
Incorrecto — eso describe una espera implícita; FluentWait debe crearse y usarse explícitamente.
Una espera que solo funciona con localizadores By.id.
Incorrecto — FluentWait funciona con cualquier condición/función, no solo con localizadores id.
FluentWait permite configurar explícitamente el timeout, el intervalo de sondeo y las excepciones ignoradas.
¿Cuáles de las siguientes son ExpectedConditions válidas de uso común con WebDriverWait? Seleccione DOS.
ExpectedConditions.visibilityOfElementLocated(By)
Correcto — espera hasta que el elemento esté presente en el DOM y visible.
ExpectedConditions.elementToBeClickable(By)
Correcto — espera hasta que el elemento sea visible y esté habilitado para poder hacer clic.
ExpectedConditions.pageToBeBeautiful()
Incorrecto — no existe tal condición; no forma parte de la API de Selenium.
ExpectedConditions.networkIdleForever()
Incorrecto — no es una ExpectedCondition real en Selenium.
visibilityOfElementLocated y elementToBeClickable son ExpectedConditions estándar; las demás son inventadas.
¿Por qué usar Thread.sleep() para la sincronización se considera un antipatrón en las pruebas de Selenium?
Siempre espera todo el tiempo fijo aunque el elemento esté listo antes, y aún puede ser demasiado corto en una ejecución lenta: lento e inestable.
Correcto — una pausa fija no se adapta al tiempo real, malgasta tiempo y aún falla de forma intermitente; las esperas condicionales son mejores.
Thread.sleep() no está disponible en Java, así que el código no compila.
Incorrecto — Thread.sleep() es Java estándar; la objeción es de comportamiento, no un error de compilación.
Cierra la sesión del navegador de forma inesperada.
Incorrecto — dormir no cierra la sesión; solo pausa el hilo.
Hace que el navegador se ejecute en modo headless.
Incorrecto — Thread.sleep no tiene nada que ver con el modo headless.
Una pausa fija siempre espera toda la duración independientemente de si el elemento está listo, lo que hace las pruebas lentas e inestables.
Una página muestra contenido dentro de un <iframe>. Una prueba falla con NoSuchElementException al localizar un elemento claramente visible dentro del frame. ¿Cuál es la causa más probable?
El driver no ha cambiado al iframe, así que el elemento está fuera de su contexto de búsqueda actual.
Correcto — hay que llamar a driver.switchTo().frame(...) antes de localizar elementos dentro de un iframe.
Selenium no puede interactuar en absoluto con elementos dentro de iframes.
Incorrecto — Selenium admite plenamente el contenido de iframes tras cambiar al frame.
El elemento solo puede localizarse con By.id cuando está dentro de un iframe.
Incorrecto — cualquier localizador funciona dentro de un frame una vez que has cambiado a él; la estrategia no es el problema.
Los iframes cierran automáticamente la sesión de WebDriver.
Incorrecto — los iframes no cierran sesiones; el fallo es un problema de contexto de búsqueda.
Los elementos dentro de un iframe no son accesibles hasta que el driver cambia a ese frame con switchTo().frame().
¿Qué API de Selenium 4 está diseñada para interacciones complejas como arrastrar y soltar, hover y combinaciones de teclas?
La clase Actions (API Actions).
Correcto — Actions construye cadenas como moveToElement, clickAndHold, dragAndDrop y keyDown/keyUp.
La clase By.
Incorrecto — By define estrategias de localización, no secuencias de interacción.
La clase ExpectedConditions.
Incorrecto — ExpectedConditions proporciona condiciones de espera, no acciones de entrada de usuario.
La clase Select.
Incorrecto — Select maneja solo desplegables <select>, no arrastrar y soltar ni hover.
La clase Actions construye secuencias de entrada de bajo nivel (ratón, teclado) para interacciones avanzadas.
Un desplegable está construido con un elemento HTML <select> estándar:
<select id="country"><option value="us">USA</option><option value="de">Germany</option></select>
¿Cuál es la forma correcta en Selenium (Java) de elegir 'Germany'?
new Select(driver.findElement(By.id("country"))).selectByVisibleText("Germany");
Correcto — la clase Select es la API adecuada para elementos <select> estándar; selectByVisibleText elige la opción por su texto.
driver.findElement(By.id("country")).sendKeys("Germany");
Incorrecto — enviar teclas al select es poco fiable; la clase Select es el enfoque correcto y portable.
driver.findElement(By.id("country")).selectOption("Germany");
Incorrecto — WebElement no tiene un método selectOption() en los bindings de Java de Selenium.
new Actions(driver).selectByVisibleText("Germany").perform();
Incorrecto — selectByVisibleText es un método de Select, no de Actions.
Para un <select> real, se usa la clase de soporte Select; selectByVisibleText('Germany') o selectByValue('de') es idiomático.
Durante una prueba aparece un alert() de JavaScript. ¿Cómo interactúa WebDriver con él?
Cambiando a él con driver.switchTo().alert() y llamando a accept() o dismiss().
Correcto — los alerts son un contexto aparte al que se llega con switchTo().alert(); luego se acepta, descarta o escribe.
Localizándolo con By.id("alert") y haciendo clic en el botón OK.
Incorrecto — los alerts nativos de JS no forman parte del DOM y no pueden localizarse con estrategias By.
WebDriver no puede manejar alerts de JavaScript.
Incorrecto — WebDriver maneja alerts mediante la interfaz Alert.
Recargando la página para que el alert desaparezca.
Incorrecto — recargar no maneja correctamente el alert y puede dejar el navegador en estado bloqueado.
Los alerts de JavaScript se manejan con driver.switchTo().alert(), luego accept()/dismiss()/sendKeys().
¿Qué devuelve driver.getWindowHandle() (singular)?
Un String que identifica la ventana enfocada actualmente.
Correcto — el método singular devuelve el handle de la ventana actual como String.
Una lista de todos los handles de ventana abiertos.
Incorrecto — eso es getWindowHandles() (plural); el singular devuelve un handle.
Las dimensiones en píxeles de la ventana.
Incorrecto — las dimensiones vienen de manage().window().getSize(), no de getWindowHandle().
El título de la página de la ventana actual.
Incorrecto — el título lo devuelve driver.getTitle(), no getWindowHandle().
getWindowHandle() devuelve el handle (string) de la ventana enfocada actual; getWindowHandles() (plural) devuelve todos.
¿Qué afirmaciones sobre el manejo de múltiples pestañas/ventanas del navegador en Selenium 4 son correctas? Seleccione DOS.
Selenium 4 puede abrir una nueva pestaña directamente con driver.switchTo().newWindow(WindowType.TAB).
Correcto — newWindow es una incorporación de Selenium 4 que abre y cambia a una nueva pestaña o ventana.
Se identifican y se cambia entre ventanas usando sus handles de ventana.
Correcto — los handles son los identificadores estables usados para cambiar el foco entre ventanas/pestañas abiertas.
WebDriver cambia automáticamente el foco a una pestaña recién abierta.
Incorrecto — abrir un enlace en una nueva pestaña no mueve el foco; hay que cambiar explícitamente por handle.
Los handles de ventana son enteros secuenciales que empiezan en 0.
Incorrecto — los handles son cadenas opacas asignadas por el navegador, no enteros ordenados.
Selenium 4 añade driver.switchTo().newWindow(WindowType.TAB) para abrir una nueva pestaña; las ventanas se siguen rastreando por handles.
¿Qué es una prueba automatizada 'flaky' (inestable)?
Una prueba que pasa y falla de forma intermitente con el mismo código sin una razón clara.
Correcto — la inestabilidad implica resultados no deterministas, a menudo por tiempo, orden o entorno.
Una prueba que siempre falla en cada ejecución.
Incorrecto — una prueba que falla siempre es determinista, no flaky.
Una prueba que no tiene aserciones.
Incorrecto — la falta de aserciones es otro problema de calidad, no inestabilidad.
Una prueba que solo se ejecuta en modo headless.
Incorrecto — la ejecución headless no tiene relación con la definición de inestabilidad.
Una prueba flaky pasa y falla de forma intermitente sin ningún cambio en el código bajo prueba.
Una prueba falla de forma intermitente al hacer clic en un botón que está presente en el DOM pero a veces todavía se está animando hacia su posición. ¿Qué solución aborda mejor la causa raíz?
Usar una espera explícita de ExpectedConditions.elementToBeClickable antes de hacer clic.
Correcto — espera hasta que el elemento sea visible y esté habilitado, cumpliendo la precondición real para un clic fiable.
Añadir Thread.sleep(500) antes de cada clic.
Incorrecto — una pausa fija es un parche frágil; malgasta tiempo y aún puede ser demasiado corta bajo carga.
Reintentar toda la prueba tres veces y aceptar el primer éxito.
Incorrecto — los reintentos a ciegas ocultan el defecto de tiempo en vez de arreglar la sincronización.
Cambiar el localizador de CSS a XPath.
Incorrecto — la estrategia de localización no es el problema; el elemento se encuentra pero aún no es interactuable.
Esperar a elementToBeClickable (visible Y habilitado) sincroniza con la interactividad, a diferencia de solo la presencia.
¿Qué prácticas ayudan a que las pruebas de Selenium sean más estables y menos inestables? Seleccione DOS.
Hacer cada prueba independiente, preparando y limpiando sus propios datos.
Correcto — el aislamiento de pruebas evita fallos causados por estado residual u orden de ejecución.
Sincronizar con el estado usando esperas explícitas basadas en condiciones en vez de pausas fijas.
Correcto — esperar la condición real se adapta al tiempo efectivo y evita tanto el tiempo malgastado como las acciones prematuras.
Compartir una sesión de navegador y el estado acumulado entre todas las pruebas.
Incorrecto — el estado mutable compartido acopla las pruebas y es una fuente común de inestabilidad.
Insertar llamadas más largas a Thread.sleep() donde una prueba falla ocasionalmente.
Incorrecto — las pausas fijas no se adaptan al tiempo y enmascaran, en vez de arreglar, el problema de sincronización subyacente.
Las pruebas independientes con sus propios datos y las esperas explícitas basadas en condiciones reducen la inestabilidad; el estado compartido y las pausas fijas la aumentan.
Un pipeline de CI ejecuta una suite de Selenium en paralelo en muchos hilos. Varias pruebas fallan de forma intermitente porque inician sesión como el mismo usuario compartido e interfieren con los datos de las demás. ¿Qué cambio elimina más directamente esta inestabilidad?
Dar a cada prueba paralela su propio usuario de prueba y conjunto de datos aislados.
Correcto — eliminar el estado mutable compartido entre pruebas paralelas suprime la interferencia cruzada en su origen.
Aumentar la espera implícita a 60 segundos.
Incorrecto — los fallos se deben a colisiones de datos, no al tiempo; una espera más larga no evita la interferencia de datos compartidos.
Ejecutar la suite en modo headless.
Incorrecto — el modo headless cambia el renderizado, no el aislamiento de datos; la colisión persiste.
Cambiar todos los localizadores a XPath absoluto.
Incorrecto — la estrategia de localización es irrelevante aquí; el problema son los datos compartidos entre pruebas concurrentes.
La causa raíz son los datos de prueba compartidos entre hilos paralelos; dar a cada prueba su propio usuario/datos aislados elimina la interferencia.
¿Por qué capturar una captura de pantalla al fallar una prueba es una práctica recomendada de estabilidad/diagnóstico?
Registra el estado de la UI en el momento del fallo, facilitando mucho el diagnóstico de problemas intermitentes.
Correcto — una captura (a menudo con el código de la página/logs) en el momento del fallo es invaluable para depurar fallos inestables o específicos del entorno.
Evita que la prueba vuelva a fallar alguna vez.
Incorrecto — una captura es un artefacto de diagnóstico; no cambia los resultados de la prueba.
Hace que el navegador se ejecute más rápido.
Incorrecto — tomar una captura no mejora la velocidad de ejecución.
Repara automáticamente los localizadores rotos.
Incorrecto — una captura solo recoge el estado; no puede reparar localizadores.
Una captura al fallar recoge el estado de la UI en el momento del fallo, acelerando mucho el análisis de causa raíz.
Un equipo quiere ejecutar la misma suite de Selenium en Chrome, Firefox y Edge sobre una infraestructura compartida. ¿Qué componente de Selenium está diseñado para esta ejecución distribuida y multinavegador?
Selenium Grid.
Correcto — Grid enruta pruebas a nodos con distintos navegadores/OS, permitiendo ejecuciones distribuidas y paralelas multinavegador.
Selenium IDE.
Incorrecto — Selenium IDE es una extensión de grabar y reproducir en el navegador, no un grid de ejecución distribuida.
La clase Actions.
Incorrecto — Actions maneja gestos de entrada complejos, no la ejecución distribuida de pruebas.
La clase PageFactory.
Incorrecto — PageFactory inicializa campos de page objects; no tiene nada que ver con la ejecución distribuida.
Selenium Grid distribuye pruebas entre varias máquinas/navegadores, permitiendo la ejecución paralela multinavegador.