Comandos importantes de Selenium webdriver de 2021

En esta serie de tutoriales, aprenderemos sobre todos los comandos exhaustivos de selenium webdriver, desde los comandos de selenium muy básicos hasta los comandos avanzados de Selenium webdriver en el siguiente orden de artículos: 

comandos selenium webdriver
Comandos de Selenium webdriver

Comandos básicos de Selenium Webdriver -Preguntas: 

  • Selenium navegar a url
  • Selenium navega hacia adelante y navega hacia atrás, es decir, navegación del navegador Selenium con historial del navegador
  • Página de actualización de selenio
  • Clic de selenio
  • Sendkeys de selenio
  • Campo de texto claro de selenio
  • Ventana de maximización de selenio
  • Ventana de minimización de selenio
  • Selenium cerrar navegador
  • Selenium sale del navegador

Selenio intermedio webdriver comandos -Preguntas:

  • Desplegable en selenio
  • Arrastrar y soltar en selenio / clase de acciones en selenio / cómo arrastrar y soltar en selenio
  • Desplazamiento del mouse en selenio
  • Alertas en selenio / cómo manejar alertas en selenio / cómo manejar ventanas emergentes en selenio
  • Clase de acción en selenio / acciones en selenio
  • Javascriptexecutor / javascriptexecutor en selenium
  • Desplácese hacia abajo en selenio / desplácese en selenio / cómo desplazarse en selenio / desplazarse hacia arriba en selenio / página hacia abajo en selenio / desplazarse hacia abajo en selenio / desplazarse hacia selenium webdriver
  • Captura de pantalla en selenio

Comandos avanzados de Selenium WebDriver -Preguntas:

  • Haga clic derecho en selenio
  • Contextclick en selenio
  • Haga doble clic en selenio
  • teclas del teclado en selenium webdriver
  • Información sobre herramientas de selenio
  • Haga clic y mantenga el selenio

Comandos básicos de selenio - Respuestas: 

Selenium navega a la URL:

En Selenium Webdriver, si queremos navegar o abrir cualquier URL específica a través de nuestro navegador, podemos hacerlo en dos enfoques diferentes, uno con el método get () y otro con navegar, veremos cómo podría ser hecho : 

public void getUrl(String url) {
  try {
     driver.get(url);
     BASE_LOGGER.info("Successfully navigated to the URL as :  " + url);
  } catch (Exception ex) {
     String exceptionData = ex.getCause().getMessage();
     BASE_LOGGER.error("Unable to navigate to URL  : " + url + " with the error as : " + exceptionData);

  }
}

El código que puede escribir para navegar por la URL es driver.get ("http://example.com") mientras que el controlador es la instancia de Webdriver de la interfaz de Selenium WebDriver.

visite aquí para comprender cómo iniciar todos los navegadores en Selenium.

¿Cómo funciona el método get internamente en Selenium? 

Una vez que se llama a este método get () desde su script de prueba, la referencia de Webdriver, es decir, el controlador esperará hasta que se cargue la página, en realidad, el método get () se activa internamente función de carga que devuelve el identificador a la referencia del controlador una vez que la página está completamente cargada.

Selenium navega hacia adelante y navega hacia atrás:

Otro enfoque para navegar a la URL con el historial del navegador es mediante el método navigate (), donde Selenium usa el historial del navegador para navegar hacia adelante o hacia atrás con sus respectivas URL como: 

El selenio navega hacia adelante

public void navigateForward() {
  try {
     driver.navigate().forward();
     BASE_LOGGER.info("Successfully navigated forward" );
  } catch (Exception ex) {
     String exceptionData = ex.getCause().getMessage();
     BASE_LOGGER.error("Unable to navigate with the error as : " + exceptionData);

  }
}

Selenium navegar hacia atrás: 

public void navigateBack() {
  try {
     driver.navigate().back();
     BASE_LOGGER.info("Successfully navigated Back to the URL ");
  } catch (Exception ex) {
     String exceptionData = ex.getCause().getMessage();
     BASE_LOGGER.error("Unable to navigate Back to URL  : with the error as : " + exceptionData);
  }
}


Página de actualización de selenio

Podemos usar el método refresh () de Selenium navigate 

public void seleniumRefreshPage() {
  try {
     driver.navigate().refresh();
     BASE_LOGGER.info("Successfully done the Selenium Refresh Page ");
  } catch (Exception ex) {
     String exceptionData = ex.getCause().getMessage();
     BASE_LOGGER.error("Unable to perform Selenium Refresh Page : with the error as : " + exceptionData);
  }
}

Clic de selenio

Para realizar cualquier operación de clic con Selenium, tenemos que usar el método llamado clic () en el enfoque a continuación, hay otras formas de realizar la operación de clic en cualquiera de los elementos Web en Selenium, es decir, utilizando JavaScriptClick, que a veces es muy útil dependiendo de las situaciones. donde su método normal de clic de selenio funciona de manera muy estable, hay algunos casos en los que si está automatizando con el navegador IE y si la aplicación web bajo prueba está construida en algún tipo de JS de arranque, entonces el método normal de clic de selenio podría no funcionar en algún momento , en ese caso, puede utilizar el método de clic de Javascript.

public void safeClick(By element) {
  try {
      driver.findElement(element).click();
     BASE_LOGGER.info("Safeclick operation has been performed for the locator : " + String.valueOf(element));

  } catch (Exception e) {

     String exceptionData = e.getCause().getMessage();
     BASE_LOGGER.error("Error encountered i.e : " + exceptionData
           + " while performing Safeclick on the element : " + element);
  }
}

Puede pasar el elemento usando diferentes estrategias de localización (es decir, xpath, name, css, etc.) en el método llamado findElement () y luego realizar la operación del método click () como la anterior.

Sendkeys de selenio

Cuando necesitamos ingresar algún texto en algún cuadro de texto a través de Selenium usamos el método sendkeys () de Selenium pasando el "Texto a ingresar" como parámetro en el método sendKeys ("Texto a ingresar") y similar a el método click () este método también se aplica a cualquier webElement (aquí cuadro de texto web) por lo que tenemos que usar driver.findElement para enviar el texto a ese TextBox.

El código de muestra es el siguiente: 

public void enterTextIntoElement(By element, String textToBeEntered) {
  try {
     driver.findElement(element).sendKeys(textToBeEntered);
     BASE_LOGGER.info(
           "enterTextIntoElement operation has been performed for the locator : " + String.valueOf(element));
  } catch (Exception ex) {
     String exceptionData = ex.getCause().getMessage();
     BASE_LOGGER.error("enterTextIntoElement operation has been failed for the locator : "
           + String.valueOf(element) + " with the exception i.e : " + exceptionData);
  }
}

Campo de texto claro de selenio

Si queremos borrar algún dato de un campo de texto previamente llenado, podemos usar el método llamado clear () y también con la ayuda de Keys Class en Selenium podemos hacerlo, a través del cual podemos tomar las Operaciones del Teclado directamente junto con los atajos de teclado :

Para borrar los datos con la ayuda del método clear (), podemos escribir en el siguiente enfoque: 

public void clearField(By element) {
  try {
     driver.findElement(element).clear();
     BASE_LOGGER.info("ClearField operation has been performed for the locator : " + String.valueOf(element));
  } catch (Exception e) {
     String exceptionData = e.getCause().getMessage();
     BASE_LOGGER.error("ClearField operation has been failed for the locator : " + String.valueOf(element)
           + " with the exception i.e : " + exceptionData);
  }
}

Al usar la clase Keys, también podemos borrar los campos de texto en el siguiente enfoque.

Ventana de maximización de selenio

Mientras trabajamos con la Automatización del navegador, si tenemos que maximizar la ventana en Selenium, entonces podríamos usar los siguientes enfoques: 

  • Usando el método maximizar () 
  • Si es un navegador Chrome, también podemos usar ChromeOptions y agregando el argumento "start-maximized" junto con ChromeOptions.

Selenium Maximize Window utilizando el método Maximize ():  

public void maximizeWindow() {
  try {
     driver.manage().window().maximize();
     BASE_LOGGER.info("Successfully Maximized the Window");
  } catch (Exception e) {
     BASE_LOGGER.info("Exception Occured while Maximizing the Window As : " + e.getCause().getMessage());
  }
}

Selenium Maximize Window mediante ChromeOptions para ChromeBrowser:

Al utilizar el método siguiente, estamos configurando una instancia del navegador Chrome para Webdriver en modo maximizado y la sesión del controlador devuelta continuará con la misma función (es decir, maximizar la ventana) para una operación web adicional según el script.

public WebDriver openBrowserInMaximizeWindow(){
  try {
     ChromeOptions options = new ChromeOptions();
     options.addArguments("start-maximized");
     WebDriver driver = new ChromeDriver(options);
    
  }catch(Exception e){
     BASE_LOGGER.error("Exception encountered with  : " + e.getCause().getMessage());
  }
  return driver;
}

Ventana de minimización de selenio

Podemos minimizar la ventana usando el comando minimizar () de Selenium con el siguiente enfoque:  

public void minimizeWindow() {
  try {
     driver.manage().window().minimize();
     BASE_LOGGER.info("Successfully Minimized the Window");

  } catch (Exception e) {
     BASE_LOGGER.info("Exception Occured while Minimizing the Window As : " + e.getCause().getMessage());
  }
}

Selenium cerrar navegador:

Para cerrar el navegador en Selenium usamos el método close () en el siguiente enfoque: 

public void closeCurrentWindow() {
  try {
     if (null != driver) {
        driver.close();
        BASE_LOGGER.info("Successfully closed the current Window/Browser");
     } else {
        BASE_LOGGER.info("Unable to close the current Window/browser instance as Its NULL");
     }
  } catch (Exception e) {
     BASE_LOGGER.info("Exception occurred while closing the current Window/Browser");
  }
}

Selenium sale del navegador

Para salir de todas las instancias del navegador en Selenium usamos el método quit () en el siguiente enfoque: 

public void quitBrowser() {
  try {
     if (null != driver) {
        driver.quit();
        BASE_LOGGER.info("Successfully QUIT Browser");
     } else {
        BASE_LOGGER.info("Unable to QUIT the Browser as Its NULL");
     }
  } catch (Exception e) {
     BASE_LOGGER.error("Exception occurred while QUITING Browser");
  }
}

Diferencia entre driver.close () y driver.quit () en Selenium:

  • driver.close () solo cierra la ventana del navegador que tiene el enfoque actual de las instancias de webdriver y, por otro lado, driver.quit () cierra todas las ventanas del navegador que están asociadas con la sesión actual de los navegadores. 
  • Internamente driver.quit () llama a un método llamado driver.dispose ().

Comandos intermedios de Selenium webdriver - respuestas:

Desplegable en selenio:

En la estructura DOM de la página web, el menú desplegable se implementa mediante Seleccionar o ingresar Tage of HTML. Para trabajar con Dropdown con Selenium y realizar ciertos 

operaciones web en los menús desplegables, debemos usar la clase "Seleccionar" de la API de Selenium WebDrivers como parte de "org.openqa.selenium.support.ui”Paquete de Selenium WebDriver. 

Hay 2 enunciados de problemas diferentes o preguntas mientras se trabaja con la selección de DropDown en Selenium: 

  • Selección de un solo elemento en un menú desplegable a la vez
  • Selección de varios elementos en un menú desplegable a la vez. 

Selección de un solo elemento en un menú desplegable a la vez

En el siguiente enfoque podemos trabajar con Dropdown:  

Paso uno :

Debe crear un identificador para DropDown WebElement usando la creación de objetos de la clase Seleccionar de la siguiente manera:

Seleccionar seleccionar = nuevo Seleccionar (WebElement webelement);

Segundo paso : 

Hay 3 enfoques diferentes para seleccionar el valor del menú desplegable en Selenium, podríamos usar cualquiera de los métodos siguientes para seleccionar el valor del menú desplegable en Selenium: 

  • selectByVisibleText
  • selectByIndex
  • selectByValue

Aquí está el siguiente enfoque que podemos tomar para seleccionar el valor del menú desplegable: 

Menú desplegable en selenio - Enfoque uno: 
En el Approach One puede utilizar el texto que es visible de la Selección Deseada del Webelement.

public void selectFromDropDownByText(By locator, String visibleText) {
  try {
     Select dropDownElement = new Select(driver.findElement(locator));
     dropDownElement.selectByVisibleText(visibleText);
     BASE_LOGGER.info("SelectFromDropDownByText operation has been performed for the locator : "
           + String.valueOf(locator));
  } catch (Exception e) {
     String exceptionData = e.getCause().getMessage();
     BASE_LOGGER.error("Error encountered i.e : " + exceptionData
           + " while performing selectFromDropDownByText on the element : " + locator);
 }
}

En el método anterior, puede pasar el localizador del menú desplegable y el texto visible que desea seleccionar del menú desplegable, luego realizará la operación deseada. Seleccione el elemento desplegable esperado. 

Menú desplegable en selenio - Enfoque dos:

En este enfoque, selecciona el elemento web mediante el atributo de valor de la selección del elemento web deseado en el menú desplegable: 

public void selectFromDropDownByValue(By locator, String visibleText) {
  try {
     Select dropDownElement = new Select(driver.findElement(locator));
     dropDownElement.selectByValue(“Desired Webelement’s value ”);
     BASE_LOGGER.info("selectFromDropDownByValue operation has been performed for the locator : "
           + String.valueOf(locator));
  } catch (Exception e) {
     String exceptionData = e.getCause().getMessage();
     BASE_LOGGER.error("Error encountered i.e : " + exceptionData
           + " while performing selectFromDropDownByValue on the element : " + locator);
  }
}

En el método anterior, puede pasar el localizador del menú desplegable y el atributo de valor del WebElement que desea seleccionar del menú desplegable, luego realizará la operación deseada seleccionando el elemento desplegable esperado. 

Desplegable en selenio - Enfoque tres:

En este Enfoque, usted selecciona el elemento Web utilizando el índice (orden del elemento Web en la etiqueta de selección HTML) de la selección del elemento Web deseado en el menú desplegable, el índice generalmente comienza desde 0:

public void selectFromDropDownByIndex(By locator, String visibleText) {
  try {
     Select dropDownElement = new Select(driver.findElement(locator));
     dropDownElement.selectByIndex(5);
     BASE_LOGGER.info("selectFromDropDownByIndex operation has been performed for the locator : "
           + String.valueOf(locator));
  } catch (Exception e) {
     String exceptionData = e.getCause().getMessage();
     BASE_LOGGER.error("Error encountered i.e : " + exceptionData
           + " while performing selectFromDropDownByIndex on the element : " + locator);
  }
}

En el método anterior, puede pasar el localizador del menú desplegable y el índice / orden del WebElement (en la etiqueta de selección del menú desplegable) del que desea seleccionar del menú desplegable, luego realizará la operación deseada seleccionando el elemento desplegable esperado .

Selección de varios elementos en un menú desplegable a la vez 

Depende de la estructura e implementación del DOM HTML si se permite que cualquier elemento desplegable tenga selección múltiple de Elementos. Para seleccionar múltiples elementos en Selenium tenemos que seguir a continuación dos pasos: 

Paso uno : Compruebe si DropDown WebElement permite la selección múltiple utilizando el método isMultiple (), esto devuelve booleano como verdadero o falso.

Segundo paso : Si el paso anterior devuelve verdadero, entonces el menú desplegable permite la selección múltiple. Y después de esto, podemos usar los tres enfoques diferentes discutidos anteriormente para seleccionar valores múltiples y realizar las operaciones deseadas.

Entonces, para concluir aquí abajo está el código de muestra:

WebElement element =driver.findElement(By.xpath("XPATH OF THE DropDown"));
Select selectMultiple = new Select(element);
if(selectMultiple.isMultiple()){
   selectMultiple.selectByIndex(1);
   selectMultiple.selectByIndex(2);
//Similarly We could use other approaches/method for selecting dropdown elements such as selectByVisibleText or selectByValue
}

Arrastra y suelta selenio :

En el segmento del tutorial aprenderemos todos los diferentes enfoques para realizar Arrastrar y soltar en Selenium, tales como: 

  • Arrastra y suelta Selenium usando el método build ().
  • Arrastre y suelte en Selenium usando el método dragAndDrop ().
  • Arrastra y suelta en Selenium usando el método dragAndDropBy ().

Qué es arrastrar y soltar en Selenium y dónde se usa: 

Arrastrar y soltar es una operación específica cuando los usuarios navegan a sus aplicaciones web e intentan realizar una operación (arrastrando con el movimiento del mouse) en algún elemento web que se puede mover libremente sobre la aplicación y se puede colocar en alguna otra ubicación de la página web de esa aplicación. 

Aquí, el elemento que se está arrastrando se llama un elemento web de origen y el elemento donde se coloca se llama un elemento web de destino. 

Para realizar los escenarios anteriores a través de la automatización con Selenium, necesitamos arrastrar y soltar las funcionalidades proporcionadas por Selenium.

Diferentes enfoques de arrastrar y soltar en selenio:

Arrastra y suelta Selenium usando el método Build (): 

Cómo funciona internamente el método Build () :

método build () de la clase Actions en Selenium que es parte del paquete org.openqa.selenium.interactions genera internamente acciones compuestas 

combinando todas las acciones que han sido llamadas o activadas antes de llamar al método build ().

Para un ejemplo :

new Actions(driver).clickAndHold(sourceElement).moveToElement(destinationElement)
       .release(destinationElement).build();

La declaración anterior para realizar la construcción de la operación de arrastrar y soltar se está utilizando para vincular las acciones anteriores, como los métodos clickAndHold, moveToElement y release.

Aquí está el siguiente fragmento de código para realizar Arrastrar y soltar en Selenium usando el método de compilación de la clase Acciones: 

public void dragAndDrop(By source, By destination) {
   try {
       WebElement sourceElement = driver.findElement(source);
       WebElement destinationElement = driver.findElement(destination);
       Actions builder = new Actions(driver);
       Action dragAndDrop = builder.clickAndHold(sourceElement).moveToElement(destinationElement)
               .release(destinationElement).build();
       dragAndDrop.perform();
       BASE_LOGGER.info("Successfully performed the Drag and Drop action ");
   } catch (Exception e) {
       String exceptionData = e.getCause().getMessage();
       BASE_LOGGER.error("Error encountered i.e : " + exceptionData + " while performing DragAndDrop ");
   }
}

Arrastre y suelte en Selenium usando el método dragAndDrop ():

Cómo funciona internamente el método dragAndDrop ():

El método dragAndDrop (sourceWebElement, destinationWebElement) básicamente toma dos argumentos, uno es fuente y otro es elemento web de destino. 
dragAndDrop elimina la necesidad de clickAndHold, moveToElement, métodos de liberación en la clase Action, maneja internamente todos los escenarios que se realizan con estos métodos.

Aquí está el siguiente fragmento de código para realizar dragAndDrop con el método dragAndDrop:

public void dragAndDropOps(By source, By destination) {
   try {
       WebElement sourceElement = driver.findElement(source);
       WebElement destinationElement = driver.findElement(destination);
       Actions builder = new Actions(driver);
       builder.dragAndDrop(sourceElement,destinationElement).perform();
       BASE_LOGGER.info("Successfully performed the Drag and Drop action ");
   } catch (Exception e) {
       String exceptionData = e.getCause().getMessage();
       BASE_LOGGER.error("Error encountered i.e : " + exceptionData + " while performing DragAndDrop ");
   }
}

Arrastrar y soltar en selenio usando el método dragAndDropBy ():

Cómo funciona internamente el método dragAndDropBy (WebElement source, int xOffset, int yOffset):

El método dragAndDropBy () toma 3 argumentos que son: 

Source WebElement: el elemento que se arrastra, es decir, el elemento fuente 

xOffset: desplazamiento de movimiento horizontal de la ubicación de destino 

yOffset: desplazamiento de movimiento vertical de la ubicación de destino 

Internamente, este método toma el elemento web de origen y lo mueve y lo libera a la ubicación de destino. Este método es útil si desea mover cualquier elemento web de origen a cualquier ubicación de píxel.

A continuación se muestra el fragmento de código para DragAndDropBy en Selenium:

public void dragAndDropByOps(By source, int xOffSet,int yOffSet) {
   try {
       WebElement sourceElement = driver.findElement(source);
       Actions builder = new Actions(driver);
       builder.dragAndDropBy(sourceElement,xOffSet,yOffSet).build().perform();
       BASE_LOGGER.info("Successfully performed the Drag and Drop action ");
   } catch (Exception e) {
       String exceptionData = e.getCause().getMessage();
       BASE_LOGGER.error("Error encountered i.e : " + exceptionData + " while performing DragAndDrop ");
   }
}

Visite aquí para ver el resto de los conjuntos avanzados de comandos de controlador web de Selenium intermedio.

Comandos avanzados de Selenium WebDriver -Respuestas:

Haga doble clic en selenio :

Para replicar la operación, es decir, hacer doble clic en Selenium con el mouse, debemos realizar un doble clic a través de la clase Acciones en Selenium y podemos hacerlo en el siguiente enfoque: 

public void doubleClick(By locator) {
   try {
       WebElement element = driver.findElement(locator);
       Actions actions = new Actions(driver);
       actions.doubleClick(element).perform();
       BASE_LOGGER.info("Performed the double Click on the Element  : " + locator);
   } catch (StaleElementReferenceException e) {
       BASE_LOGGER.error("Element is not attached to the page document " + e.getCause().getMessage());
   } catch (NoSuchElementException e) {
       BASE_LOGGER.error("Element " + locator + " was not found in DOM " + e.getCause().getMessage());
   } catch (Exception e) {
       BASE_LOGGER.error("Element " + locator + " was not clickable " + e.getCause().getMessage());
   }
}

El fragmento de código anterior es un método que básicamente toma un argumento como Locator, es decir, el WebElement en el que se debe realizar el doble clic.

Haga clic en contexto en selenio:

Para replicar la operación de clic de contexto o clic derecho a través del mouse, necesitamos realizar el método de clic de contexto a través de la clase Actions en Selenium y podemos hacerlo en el siguiente enfoque: 

public void rightClick(By locator) {
   try {
       WebElement element = driver.findElement(locator);
       Actions actions = new Actions(driver);
       actions.contextClick(element).perform();
       BASE_LOGGER.info("Performed the context Click on the Element  : " + locator);
   } catch (StaleElementReferenceException e) {
       BASE_LOGGER.error("Element is not attached to the page document " + e.getCause().getMessage());
   } catch (NoSuchElementException e) {
       BASE_LOGGER.error("Element " + locator + " was not found in DOM " + e.getCause().getMessage());
   } catch (Exception e) {
       BASE_LOGGER.error("Element " + locator + " was not clickable " + e.getCause().getMessage());
   }
}

Para obtener los comandos detallados del controlador web de Advance Selenium, visite aquí. También para comprender la clase Actions en Selenium y sus implementaciones, visite aquí.

Preguntas frecuentes críticas: 

¿Qué es manage () en Selenium?

driver.manage () devuelve una referencia de implementación de WebDriver.Options Interface.Options interfaz es una interfaz para administrar y manejar acciones en un menú del navegador como: 

  • addCookie
  • deleteCookie
  • getCookies
  • Operaciones de ventana

Para juegos exhaustivos de Preguntas de la entrevista de selenio -Conjuntos críticos y avanzados, visite aquí.

conclusión:

En esta sección del tutorial cubrimos lo básico Controlador web de selenio comandos, haga clic aquí para aprender Comandos intermedios y avanzados de Selenium webdriver. Para aprender Selenium from Scratch, haga clic aquí.

Sobre Debarghya

Yo mismo, Debarghya Roy, soy un ARQUITECTO de ingeniería que trabaja con una compañía de Fortune 5 y un colaborador de código abierto, con alrededor de 12 años de experiencia / conocimientos en varias tecnologías.
He trabajado con diversas tecnologías como Java, C #, Python, Groovy, UI Automation (Selenium), Mobile Automation (Appium), API / Backend Automation, Performance Engineering (JMeter, Locust), Security Automation (MobSF, OwAsp, Kali Linux , Astra, ZAP, etc.), RPA, automatización de ingeniería de procesos, automatización de mainframe, desarrollo de back-end con SpringBoot, Kafka, Redis, RabitMQ, ELK stack, GrayLog, Jenkins y también con experiencia en tecnologías de nube, DevOps, etc.
Vivo en Bangalore, India con mi esposa y tengo pasión por los blogs, la música, tocar la guitarra y mi Filosofía de vida es Educación para Todos, que dio origen a LambdaGeeks. Vamos a conectarnos a través de enlaces: https://www.linkedin.com/in/debarghya-roy/

Deja un comentario

Tu dirección de correo electrónico no será publicada.Los campos obligatorios están marcados *