Navegación básica

Navegación

Los métodos de navegación constituyen la base de cualquier automatización web con Selenium. 

WebDriver proporciona varias formas de controlar el navegador y moverse entre páginas, cada una con características específicas que determinan cuándo y cómo utilizarlas.

El método get()

El método get() representa la forma más directa de cargar una página web. Este método bloquea la ejecución hasta que la página se haya cargado completamente, incluyendo todos los recursos asociados como CSS, JavaScript e imágenes.

@Test
void navegacionConGet() {
    driver.get("https://example.com");
    // El navegador espera hasta que la página esté completamente cargada
    
    String tituloActual = driver.getTitle();
    assertEquals("Example Domain", tituloActual);
}

La característica principal del método get() es su comportamiento síncrono: garantiza que el DOM esté disponible antes de continuar con la siguiente instrucción. Esto lo convierte en la opción ideal para la carga inicial de páginas en pruebas automatizadas.

La interfaz Navigation

WebDriver proporciona una interfaz más rica para la navegación a través del objeto Navigation, accesible mediante driver.navigate(). Esta interfaz ofrece métodos que simulan las acciones típicas de un usuario con el navegador.

Navegación directa con navigate().to():

@Test
void navegacionConNavigateTo() {
    driver.navigate().to("https://example.com");
    
    // También acepta objetos URL
    URL url = new URL("https://example.com/login");
    driver.navigate().to(url);
}

Navegación hacia atrás y adelante:

@Test
void navegacionHistorial() {
    // Cargar página inicial
    driver.get("https://example.com");
    
    // Navegar a otra página
    driver.navigate().to("https://example.com/about");
    
    // Retroceder una página (como el botón "Atrás" del navegador)
    driver.navigate().back();
    assertEquals("https://example.com", driver.getCurrentUrl());
    
    // Avanzar una página (como el botón "Adelante" del navegador)
    driver.navigate().forward();
    assertEquals("https://example.com/about", driver.getCurrentUrl());
}

Actualización de página:

@Test
void actualizacionPagina() {
    driver.get("https://example.com");
    
    // Actualizar la página (equivalente a F5 o Ctrl+R)
    driver.navigate().refresh();
    
    // Útil cuando el contenido de la página cambia dinámicamente
    String contenidoActualizado = driver.getPageSource();
    assertNotNull(contenidoActualizado);
}

Diferencias clave entre get() y navigate().to()

Aunque ambos métodos cargan páginas web, presentan diferencias importantes en su comportamiento interno:

Gestión del historial del navegador: El método get() reemplaza la entrada actual en el historial, mientras que navigate().to() añade una nueva entrada. Esta diferencia es crucial cuando planeas utilizar los métodos back() y forward().

@Test
void diferenciaHistorial() {
    // Con get() - no se puede volver atrás
    driver.get("https://example.com");
    driver.get("https://example.com/page2");
    
    // Este navigate().back() no funcionará como esperamos
    // porque get() reemplazó la entrada del historial
    
    // Con navigate().to() - se mantiene el historial
    driver.navigate().to("https://example.com");
    driver.navigate().to("https://example.com/page2");
    driver.navigate().back(); // Funciona correctamente
}

Rendimiento y caché: El método navigate().to() puede aprovechar mejor la caché del navegador para recursos ya descargados, mientras que get() tiende a realizar una carga más completa de la página.

La elección del método depende del contexto específico de tu prueba:

• Utiliza get() para cargas iniciales de páginas o cuando necesites garantizar una carga completa y limpia de recursos.
• Utiliza navigate().to() cuando formes parte de un flujo de navegación que requiera usar el historial del navegador posteriormente.
• Utiliza navigate().back() y navigate().forward() para simular comportamientos reales de usuario navegando por el historial.
• Utiliza navigate().refresh() para validar que el contenido dinámico se actualiza correctamente o para resetear el estado de la página.

@Test
void flujoNavegacionCompleto() {
    // Carga inicial con get()
    driver.get("https://tienda.example.com");
    
    // Navegación a catálogo manteniendo historial
    driver.navigate().to("https://tienda.example.com/catalogo");
    
    // Navegación a producto específico
    driver.navigate().to("https://tienda.example.com/producto/123");
    
    // Volver al catálogo usando historial
    driver.navigate().back();
    assertEquals("https://tienda.example.com/catalogo", driver.getCurrentUrl());
    
    // Actualizar catálogo para ver nuevos productos
    driver.navigate().refresh();
}

Esta combinación estratégica de métodos de navegación permite crear pruebas que replican fielmente los patrones de navegación de usuarios reales, mejorando la cobertura y fiabilidad de las pruebas automatizadas.

Gestión de ventanas y pestañas

La gestión de ventanas y pestañas es fundamental en las pruebas web modernas, donde las aplicaciones frecuentemente abren contenido en nuevas ventanas o pestañas. 

Selenium WebDriver proporciona un conjunto completo de métodos para identificar, cambiar entre y controlar múltiples contextos de navegación.

Identificación de ventanas

Cada ventana o pestaña en el navegador tiene un identificador único llamado "window handle". WebDriver proporciona métodos específicos para obtener estos identificadores y trabajar con ellos.

Obtener el handle de la ventana actual:

@Test
void obtenerHandleVentanaActual() {
    driver.get("https://example.com");
    
    String ventanaOriginal = driver.getWindowHandle();
    assertNotNull(ventanaOriginal);
    
    // El handle es único para cada sesión del navegador
    System.out.println("Handle de ventana actual: " + ventanaOriginal);
}

Obtener todos los handles disponibles:

@Test
void obtenerTodosLosHandles() {
    driver.get("https://example.com");
    
    Set<String> todasLasVentanas = driver.getWindowHandles();
    assertEquals(1, todasLasVentanas.size());
    
    // Abrir una nueva pestaña (simulando clic en enlace con target="_blank")
    driver.findElement(By.linkText("Abrir en nueva pestaña")).click();
    
    // Ahora deberíamos tener dos ventanas
    Set<String> ventanasActualizadas = driver.getWindowHandles();
    assertEquals(2, ventanasActualizadas.size());
}

Cambio entre ventanas

El método switchTo().window() permite cambiar el contexto de WebDriver a una ventana específica. Una vez realizado el cambio, todas las operaciones subsequentes se ejecutarán en la nueva ventana activa.

@Test
void cambiarEntreVentanas() {
    driver.get("https://example.com");
    String ventanaOriginal = driver.getWindowHandle();
    
    // Abrir nueva ventana mediante JavaScript
    ((JavascriptExecutor) driver).executeScript("window.open('https://example.com/nueva-pagina')");
    
    // Obtener todas las ventanas y encontrar la nueva
    Set<String> todasLasVentanas = driver.getWindowHandles();
    
    String nuevaVentana = todasLasVentanas.stream()
        .filter(handle -> !handle.equals(ventanaOriginal))
        .findFirst()
        .orElseThrow();
    
    // Cambiar a la nueva ventana
    driver.switchTo().window(nuevaVentana);
    assertEquals("https://example.com/nueva-pagina", driver.getCurrentUrl());
    
    // Volver a la ventana original
    driver.switchTo().window(ventanaOriginal);
    assertEquals("https://example.com", driver.getCurrentUrl());
}

Nuevo método newWindow()

Selenium 4 introduce el método newWindow(), que simplifica significativamente la creación y cambio a nuevas ventanas o pestañas sin requerir JavaScript adicional.

Crear nueva pestaña:

@Test
void crearNuevaPestana() {
    driver.get("https://example.com");
    String ventanaOriginal = driver.getWindowHandle();
    
    // Crear y cambiar automáticamente a nueva pestaña
    driver.switchTo().newWindow(WindowType.TAB);
    
    // Navegar en la nueva pestaña
    driver.get("https://example.com/otra-pagina");
    assertEquals("https://example.com/otra-pagina", driver.getCurrentUrl());
    
    // Verificar que tenemos dos pestañas
    assertEquals(2, driver.getWindowHandles().size());
    
    // Volver a la pestaña original
    driver.switchTo().window(ventanaOriginal);
}

Crear nueva ventana:

@Test
void crearNuevaVentana() {
    driver.get("https://example.com");
    
    // Crear nueva ventana independiente
    driver.switchTo().newWindow(WindowType.WINDOW);
    
    driver.get("https://example.com/configuracion");
    
    // Las nuevas ventanas son completamente independientes
    // y pueden tener diferentes dimensiones, posiciones, etc.
    driver.manage().window().setSize(new Dimension(800, 600));
}

Diferencias entre close() y quit()

La gestión del ciclo de vida de ventanas requiere entender las diferencias críticas entre los métodos close() y quit().

El método close():

@Test
void cerrarVentanaEspecifica() {
    driver.get("https://example.com");
    
    // Abrir nueva pestaña
    driver.switchTo().newWindow(WindowType.TAB);
    driver.get("https://example.com/temporal");
    
    // close() cierra solo la ventana/pestaña actual
    driver.close();
    
    // El driver sigue activo, pero necesitamos cambiar a una ventana válida
    String ventanaRestante = driver.getWindowHandles().iterator().next();
    driver.switchTo().window(ventanaRestante);
    
    // Podemos continuar trabajando
    assertEquals("https://example.com", driver.getCurrentUrl());
}

El método quit():

@Test
void cerrarSesionCompleta() {
    driver.get("https://example.com");
    
    // Abrir múltiples pestañas
    driver.switchTo().newWindow(WindowType.TAB);
    driver.switchTo().newWindow(WindowType.TAB);
    
    assertEquals(3, driver.getWindowHandles().size());
    
    // quit() cierra TODAS las ventanas y termina la sesión
    driver.quit();
    
    // Después de quit(), el driver ya no es utilizable
    // Cualquier operación posterior lanzará una excepción
}

Patrones prácticos de gestión

Patrón de ventana temporal:

@Test
void patronVentanaTemporal() {
    driver.get("https://tienda.example.com/productos");
    String ventanaPrincipal = driver.getWindowHandle();
    
    // Abrir detalles de producto en nueva pestaña
    driver.switchTo().newWindow(WindowType.TAB);
    driver.get("https://tienda.example.com/producto/123");
    
    // Realizar acciones en la ventana temporal
    String nombreProducto = driver.findElement(By.className("product-name")).getText();
    String precio = driver.findElement(By.className("price")).getText();
    
    // Cerrar ventana temporal y volver a la principal
    driver.close();
    driver.switchTo().window(ventanaPrincipal);
    
    // Continuar con el flujo principal
    driver.findElement(By.id("search")).sendKeys(nombreProducto);
}

Gestión de múltiples ventanas con Stream API:

@Test
void gestionMultiplesVentanas() {
    driver.get("https://example.com");
    String ventanaInicial = driver.getWindowHandle();
    
    // Abrir varias pestañas
    List<String> urls = List.of(
        "https://example.com/pagina1",
        "https://example.com/pagina2",
        "https://example.com/pagina3"
    );
    
    urls.forEach(url -> {
        driver.switchTo().newWindow(WindowType.TAB);
        driver.get(url);
    });
    
    // Procesar cada ventana
    driver.getWindowHandles().stream()
        .filter(handle -> !handle.equals(ventanaInicial))
        .forEach(handle -> {
            driver.switchTo().window(handle);
            String titulo = driver.getTitle();
            System.out.println("Procesando: " + titulo);
        });
    
    // Volver a ventana inicial
    driver.switchTo().window(ventanaInicial);
}

Mejores prácticas

Siempre mantén referencia a la ventana principal:

@Test
void mejoresPracticasVentanas() {
    driver.get("https://example.com");
    final String VENTANA_PRINCIPAL = driver.getWindowHandle();
    
    try {
        // Trabajo con nuevas ventanas
        driver.switchTo().newWindow(WindowType.TAB);
        driver.get("https://example.com/formulario");
        
        // Realizar operaciones...
        
    } finally {
        // Garantizar retorno a ventana principal
        if (driver.getWindowHandles().contains(VENTANA_PRINCIPAL)) {
            driver.switchTo().window(VENTANA_PRINCIPAL);
        }
    }
}

La gestión eficiente de ventanas y pestañas permite crear pruebas robustas que manejan escenarios complejos de navegación multi-ventana, replicando comportamientos reales de usuario y garantizando la limpieza adecuada de recursos del navegador.