L’Outil Surpuissant pour Exploser ton Chiffre d'Affaires en 2025 !
Un guide sur la cartographie des flux / Blogs / Perficient
Dans le paysage en constante évolution de l’automatisation Web, Selenium est devenu un outil puissant pour les testeurs et les développeurs. L’un des aspects clés de la flexibilité de Selenium réside dans sa capacité à s’adapter à des méthodes personnalisées, offrant ainsi une approche claire pour gérer des scénarios complexes. Dans ce blog, nous approfondirons le domaine du développement de méthodes Selenium personnalisées en utilisant les capacités dynamiques et expressives du mappage de flux.
Construire une fondation
Avant de plonger dans les complexités de la cartographie des flux dans Selenium, établissons une compréhension fondamentale des principes impliqués. Une connaissance des bases de Java et de Selenium est recommandée pour bien comprendre les concepts abordés dans ce guide.
Retrouvez nos blogs précédents :
Comprendre le mappage de flux
Le mappage de flux, une fonctionnalité intégrale de Java, fournit un moyen concis et expressif de manipuler des collections de données. L’exploitation de cette fonctionnalité dans Selenium permet aux développeurs de créer des méthodes personnalisées interagissant de manière transparente avec les éléments Web, offrant ainsi un processus d’automatisation rationalisé et efficace.
Nous pouvons voir un exemple de sélénium de construction personnalisé utilisant un mappeur de flux dans l’exemple mentionné ci-dessous :
List<String>price= elementsList.stream().filter(s>s.getText().contains("Beans")). map(s>getPriceVeggi(s)).collect(Collectors.toList());
price.forEach(s->System.out.println(s));
}
private static String getPriceVeggie(WebElement s) {
String pricevalue= s.findElement(By.xpath("following-sibling::td[1]")).getText();
return pricevalue;
Explication
Cet extrait de code illustre notre utilisation efficace des méthodes. Nous commençons par convertir les éléments en flux, puis filtrer les valeurs en fonction de la spécification « contient ». Ce processus nous permet d’envoyer uniquement les valeurs d’éléments spécifiques plutôt que l’ensemble du flux, cartographiant ensuite le prix des valeurs contenues.
Dans les scénarios nécessitant que certaines conditions soient remplies, nous appliquons la méthode de filtrage comme d’habitude pour affiner les valeurs. Par conséquent, cette approche isole précisément les éléments souhaités. La méthode ‘getPriceVeggi’, située en bas, est dédiée à l’élaboration d’une logique qui récupère la valeur d’un bean spécifique.
Saisir
package practice;
import java.util.List;
import java.util.stream.Collectors;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.Assert;
import io.github.bonigarcia.wdm.WebDriverManager;
public class WebTableSortingUsingStreams {
public static void main(String[] args) {
// TODO Auto-generated method stub
//Managing the browser
WebDriverManager.chromedriver().setup();
WebDriver driver = new ChromeDriver();
//Maximizing the browser
driver.manage().window().maximize();
//Navigating to the URL
driver.get("https://rahulshettyacademy.com/seleniumPractise/#/offers");
//Click on Column using the xpath
driver.findElement(By.xpath("//tr/th[1]")).click();
//capture all web elements of the column into list again by using xpath.
List<WebElement> elementsList = driver.findElements(By.xpath("//tr/td[1]"));
//capture text of all webelements into new(original) list, in this we are converting the elements of
//list into a stream format by making the use of .stream method and then mapping them using .map
List<String> originalList = elementsList.stream().map(s->s.getText()).collect(Collectors.toList());
//sorting method is used on the original list of step 3 -> sorted list
List<String>sortedList = originalList.stream().sorted().collect(Collectors.toList());
//Now, we use assertion to compare original list vs sorted list (both should look same)
Assert.assertTrue(originalList.equals(sortedList));
//It scans the names in a column with getText (for example, it might find 'Beans'), then prints the price of that specific element using the
// 'getPriceVeggi' method. This method, in turn, creates its own new method where we specify the XPath of the WebElement.
List<String>price= elementsList.stream().filter(s->s.getText().contains("Beans")).map(s->getPriceVeggie(s)).collect(Collectors.toList());
price.forEach(s->System.out.println(s));
}
//A new method has been crafted for "getPriceVeggi," serving its purpose within stream manipulation to identify the specific WebElement among a list of WebElements
private static String getPriceVeggie(WebElement s) {
String pricevalue= s.findElement(By.xpath("following-sibling::td[1]")).getText();
return pricevalue;
}
}
Sortir
38
Avantages des méthodes Selenium personnalisées avec le mappage des flux
Lisibilité du code
Le mappage de flux favorise un code concis et lisible, permettant aux développeurs et aux testeurs de comprendre et de gérer plus facilement les scripts d’automatisation.
Réutilisabilité
Les méthodes personnalisées développées à l’aide du mappage de flux peuvent être réutilisées dans différents projets, réduisant ainsi la redondance et améliorant l’efficacité de votre cadre d’automatisation.
Adaptabilité
Le mappage de flux permet l’adaptation dynamique des scripts d’automatisation aux modifications des éléments Web, garantissant ainsi la longévité et la résilience de vos projets basés sur Selenium.
Conclusion
L’intégration de méthodes Selenium personnalisées grâce à l’utilisation du mappage de flux ouvre un monde de possibilités pour les passionnés d’automatisation Web. En combinant la puissance de Selenium avec la nature expressive du flux Java, les développeurs et les testeurs peuvent créer des scripts d’automatisation robustes, adaptables et efficaces. Profitez de la flexibilité offerte par le mappage de flux et élevez vos projets d’automatisation Selenium vers de nouveaux sommets de sophistication et d’efficacité.
Bonne lecture!
Source link