Commandes importantes de Selenium Webdriver de 2021

Dans cette série de didacticiels, nous allons découvrir toutes les commandes exhaustives de sélénium webdriver à partir des commandes très basiques sélénium aux commandes avancées Selenium webdriver dans l'ordre des articles ci-dessous: 

commandes sélénium webdriver
Commandes Selenium Webdriver

Commandes de base de Selenium Webdriver - Questions: 

  • Selenium accéder à l'URL
  • Sélénium naviguer vers l'avant et revenir en arrière, c'est-à-dire la navigation du navigateur Selenium avec l'historique du navigateur
  • Page de rafraîchissement du sélénium
  • Clic de sélénium
  • Touches d'envoi sélénium
  • Champ de texte clair Selenium
  • Fenêtre de maximisation du sélénium
  • Fenêtre de réduction du sélénium
  • Sélénium fermer le navigateur
  • Selenium quitter le navigateur

Sélénium intermédiaire Webdriver commandes -Des questions:

  • Dropdown dans le sélénium
  • Glisser-déposer dans le sélénium / Classe d'actions dans le sélénium / Comment glisser-déposer dans le sélénium
  • Survol de la souris dans le sélénium
  • Alertes en sélénium / Comment gérer les alertes en sélénium / Comment gérer les popup en sélénium
  • Classe d'action en sélénium / actions en sélénium
  • Javascriptexecutor / javascriptexecutor en sélénium
  • Faire défiler vers le bas dans le sélénium / faire défiler dans le sélénium / comment faire défiler dans le sélénium / faire défiler vers le haut dans le sélénium / page vers le bas dans le sélénium / faire défiler la page dans le sélénium / faire défiler le sélénium webdriver
  • Capture d'écran sur sélénium

Commandes avancées de Selenium WebDriver -Des questions:

  • Clic droit dans le sélénium
  • Contextclick dans le sélénium
  • Double-cliquez sur le sélénium
  • touches du clavier dans le webdriver sélénium
  • Info-bulle sur le sélénium
  • Sélénium Click and Hold

Commandes de base Selenium - Réponses: 

Selenium accédez à l'URL:

Dans Selenium Webdriver, si nous voulons naviguer ou ouvrir une URL spécifique via notre navigateur, nous pouvons le faire dans principalement deux approches différentes, l'une avec la méthode get () et l'autre avec la navigation, nous allons voir comment cela pourrait être terminé : 

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);

  }
}

Le code que vous pouvez écrire pour naviguer dans l'url est driver.get («http://example.com») tandis que le pilote est l'instance Webdriver de l'interface Selenium WebDriver.

visitez ici pour comprendre comment lancer tous les navigateurs dans Selenium.

Comment fonctionne la méthode get en interne dans Selenium: 

Une fois que cette méthode get () est appelée à partir de votre script de test, la référence Webdriver c'est-à-dire que le pilote attendra que la page soit chargée, en fait la méthode get () se déclenche en interne fonction onload qui renvoie le handle de votre référence de pilote une fois que la page est complètement chargée.

Selenium naviguer vers l'avant et revenir en arrière:

Une autre approche pour naviguer vers l'URL avec l'historique du navigateur consiste à utiliser la méthode navigate (), où le Selenium utilise l'historique du navigateur pour naviguer en avant ou en arrière avec vos URL respectives telles que: 

Sélénium avance

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);

  }
}

Sélénium revenir en arrière: 

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);
  }
}


Page de rafraîchissement du sélénium

Nous pouvons utiliser la méthode refresh () de Selenium naviguer 

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 sélénium

Afin d'effectuer toute opération de clic avec Selenium click, nous devons utiliser la méthode appelée click () dans l'approche ci-dessous, il existe d'autres moyens d'effectuer une opération de clic sur l'un des WebElement dans Selenium, c'est-à-dire en utilisant JavaScriptClick qui est parfois très utile selon les situations où votre méthode de clic Selenium normale fonctionne de manière très stable, dans certains cas, si vous automatisez avec le navigateur IE et si l'application Web testée est construite dans une sorte de bootstrap JS, la méthode de clic sélénium normale peut parfois ne pas fonctionner , dans ce cas, vous pouvez utiliser la méthode de clic 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);
  }
}

Vous pouvez passer l'élément en utilisant différentes stratégies de localisation (c'est-à-dire xpath, name, css, etc.) dans la méthode appelée findElement (), puis effectuer l'opération de la méthode click () comme ci-dessus.

Touches d'envoi sélénium

Lorsque nous devons saisir du texte dans une zone de texte via Selenium, nous utilisons la méthode Selenium sendkeys () en passant le "Texte à saisir" comme paramètre dans la méthode sendKeys ("Texte à saisir") et similaire à la méthode click () cette méthode est également appliquée à n'importe quel webElement (ici la zone de texte Web), nous devons donc utiliser driver.findElement pour envoyer le texte à cette zone de texte.

L'exemple de code va comme ceci: 

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);
  }
}

Champ de texte clair Selenium

Si nous voulons effacer des données d'un champ de texte précédemment rempli, nous pouvons utiliser la méthode appelée clear () et également à l'aide de Keys Class dans Selenium, nous pouvons le faire, à travers laquelle nous pouvons effectuer les opérations au clavier directement avec des raccourcis clavier :

Pour effacer les données à l'aide de la méthode clear (), nous pouvons écrire dans l'approche ci-dessous: 

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);
  }
}

En utilisant la classe Keys, nous pouvons également effacer les champs de texte dans l'approche suivante.

Fenêtre de maximisation du sélénium

Tout en travaillant avec l'automatisation du navigateur, si nous devons maximiser la fenêtre dans Selenium, nous pourrions utiliser les approches suivantes: 

  • En utilisant la méthode maximiser () 
  • Si c'est un ChromeBrowser, nous pouvons également utiliser ChromeOptions et en ajoutant l'argument «start-maximized» avec les ChromeOptions.

Selenium Maximize Window à l'aide de la méthode 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 à l'aide de ChromeOptions pour ChromeBrowser:

En utilisant la méthode ci-dessous, nous définissons une instance de navigateur Chrome pour Webdriver en mode maximisé et la session de pilote retournée continuera avec la même fonctionnalité (c'est-à-dire maximiser la fenêtre) pour une opération Web ultérieure selon le 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;
}

Fenêtre de réduction du sélénium

Nous pouvons minimiser la fenêtre en utilisant la commande Selenium minimiser () avec l'approche suivante:  

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());
  }
}

Navigateur fermé Selenium:

Pour fermer le navigateur dans Selenium, nous utilisons la méthode close () dans l'approche ci-dessous: 

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 quitter le navigateur

Pour quitter toutes les instances de navigateur dans Selenium, nous utilisons la méthode quit () dans l'approche ci-dessous: 

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");
  }
}

Différence entre driver.close () et driver.quit () dans Selenium:

  • driver.close () ne ferme que la fenêtre du navigateur qui a le focus actuel des instances de webdriver et, d'autre part, driver.quit () ferme toutes les fenêtres du navigateur qui sont associées à la session courante des navigateurs. 
  • En interne, driver.quit () appelle une méthode appelée driver.dispose ().

Commandes Intermediate Selenium Webdriver - Réponses:

Dropdown dans le sélénium:

Dans la structure DOM de la page Web, la liste déroulante est implémentée soit par Select, soit par l'entrée Tage of HTML .Pour travailler avec Dropdown avec Selenium et effectuer certains 

opérations Web sur les listes déroulantes, nous devons utiliser la classe "Select" de l'API Selenium WebDrivers dans le cadre de "org.openqa.selenium.support.ui”De Selenium WebDriver. 

Il y a 2 énoncé de problème ou demander différents lorsque vous travaillez avec la sélection de DropDown dans Selenium: 

  • Sélection d'un seul élément dans une liste déroulante à la fois
  • Sélection de plusieurs éléments dans une liste déroulante à la fois. 

Sélection d'un seul élément dans une liste déroulante à la fois

Dans l'approche ci-dessous, nous pouvons travailler avec Dropdown:  

La première étape :

Vous devez créer un handle pour le DropDown WebElement en utilisant la création de classe Select Object de la manière ci-dessous:

Sélectionnez select = new Select (WebElement webelement);

Deuxième étape: 

Il existe 3 approches différentes pour sélectionner la valeur dans la liste déroulante de Selenium, nous pourrions utiliser l'une des méthodes ci-dessous pour sélectionner la valeur dans la liste déroulante de Selenium: 

  • selectByVisibleText
  • selectParIndex
  • selectParValeur

Voici l'approche ci-dessous que nous pouvons adopter pour sélectionner une valeur dans la liste déroulante: 

Dropdown dans le sélénium - Approche One: 
Dans l'Approach One, vous pouvez utiliser le texte visible de la sélection souhaitée du 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);
 }
}

Dans la méthode ci-dessus, vous pouvez passer le localisateur de la liste déroulante et le texte visible que vous souhaitez sélectionner dans la liste déroulante, puis il effectuera l'opération souhaitée Sélection de l'élément déroulant attendu. 

Dropdown dans le sélénium - Approche deux:

Dans cette approche, vous sélectionnez le Webelement en utilisant l'attribut value de la sélection WebElement souhaitée dans la liste déroulante: 

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);
  }
}

Dans la méthode ci-dessus, vous pouvez passer le localisateur de la liste déroulante et l'attribut de valeur du WebElement que vous souhaitez sélectionner dans la liste déroulante, puis il effectuera l'opération souhaitée Sélection de l'élément déroulant attendu. 

Liste déroulante dans le sélénium - Approche trois:

Dans cette approche, vous sélectionnez le Webelement en utilisant l'index (ordre du WebElement dans la balise de sélection HTML) de la sélection WebElement souhaitée dans la liste déroulante, l'index commence généralement à 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);
  }
}

Dans la méthode ci-dessus, vous pouvez passer le localisateur de la liste déroulante et l'index / l'ordre du WebElement (dans la balise de sélection de la liste déroulante) dont vous souhaitez sélectionner dans la liste déroulante, puis il effectuera l'opération souhaitée Sélection de l'élément déroulant attendu .

Sélection de plusieurs éléments dans une liste déroulante à la fois 

Cela dépend de la structure et de l'implémentation du DOM HTML si un élément déroulant est autorisé à avoir une sélection multiple d'éléments. Pour sélectionner plusieurs éléments dans Selenium, nous devons suivre les deux étapes ci-dessous: 

La première étape : Vérifiez si DropDown WebElement autorise la sélection multiple en utilisant la méthode isMultiple (), cela renvoie booléen comme vrai ou faux.

Deuxième étape: si l'étape ci-dessus renvoie true, la liste déroulante permet la sélection multiple. Et après cela, nous pouvons utiliser les trois approches décrites ci-dessus pour sélectionner plusieurs valeurs et effectuer les opérations souhaitées.

Donc, pour conclure, voici l'exemple de code:

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
}

Glisser-déposer dans le sélénium :

Dans le segment du didacticiel, nous allons apprendre toutes les différentes approches de l'exécution du glisser-déposer dans Selenium telles que: 

  • Glissez-déposez dans Selenium en utilisant la méthode build ().
  • Faites glisser et déposez dans Selenium à l'aide de la méthode dragAndDrop ().
  • Glissez-déposez dans Selenium à l'aide de la méthode dragAndDropBy ().

Qu'est-ce que le glisser-déposer dans Selenium et où il est utilisé: 

Le glisser-déposer est une opération spécifique lorsque les utilisateurs naviguent vers vos applications Web et tentent d'effectuer une opération (glisser par déplacement de la souris) sur un élément Web qui peut se déplacer librement sur l'application et peut être déposé à un autre emplacement de la page Web de cette application. 

Ici, l'élément qui est glissé est appelé un WebElement source et l'élément où il est déposé est appelé un WebElement de destination. 

Pour exécuter les scénarios ci-dessus via l'automatisation avec Selenium, nous devons glisser-déposer les fonctionnalités fournies par Selenium.

Différentes approches du glisser-déposer dans Selenium:

Glissez-déposez dans Selenium en utilisant la méthode Build (): 

Comment la méthode Build () fonctionne en interne :

build () de la classe Actions dans Selenium qui fait partie du package org.openqa.selenium.interactions génère en interne des actions composites 

en combinant toutes les actions qui ont été appelées ou déclenchées avant d'appeler la méthode build ().

À titre d'exemple :

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

L'instruction ci-dessus pour effectuer la génération d'opération de glisser-déposer est utilisée pour lier les actions précédentes telles que les méthodes clickAndHold, moveToElement et release.

Voici l'extrait de code ci-dessous pour effectuer le glisser-déposer dans Selenium à l'aide de la méthode de construction de la classe Actions: 

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 ");
   }
}

Faites glisser et déposez dans Selenium à l'aide de la méthode dragAndDrop ():

Comment la méthode dragAndDrop () fonctionne en interne:

La méthode dragAndDrop (sourceWebElement, destinationWebElement) prend essentiellement deux arguments, l'un est la source et l'autre est l'élément web de destination. 
dragAndDrop supprime le besoin de clickAndHold, moveToElement, libérez des méthodes dans la classe Action, il gère en interne tous les scénarios qui sont exécutés par ces méthodes.

Voici l'extrait de code ci-dessous pour effectuer dragAndDrop avec la méthode 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 ");
   }
}

Glisser-déposer dans Selenium à l'aide de la méthode dragAndDropBy ():

Comment la méthode dragAndDropBy (WebElement source, int xOffset, int yOffset) fonctionne en interne:

La méthode dragAndDropBy () prend 3 arguments qui sont: 

Source WebElement: l'élément qui est glissé c'est-à-dire l'élément source 

xOffset: décalage de déplacement horizontal de l'emplacement de destination 

yOffset: décalage de déplacement vertical de l'emplacement de destination 

En interne, cette méthode prend l'élément Web source, le déplace et le libère vers l'emplacement de destination. Cette méthode est utile si vous souhaitez déplacer un élément Web source vers n'importe quel emplacement de pixel.

Vous trouverez ci-dessous l'extrait de code pour DragAndDropBy dans 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 ");
   }
}

Visitez ici pour le reste des ensembles avancés de commandes Webdriver Selenium intermédiaire.

Commandes avancées de Selenium WebDriver -Réponses:

Double-cliquez sur le sélénium :

Pour reproduire l'opération, c'est-à-dire double-cliquer dans Selenium via la souris, nous devons effectuer un double-clic via la classe Actions dans Selenium et nous pouvons le faire dans l'approche ci-dessous: 

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());
   }
}

L'extrait de code ci-dessus est une méthode qui prend essentiellement un argument comme Locator, c'est-à-dire le WebElement sur lequel le double-clic doit être effectué.

Contextclick dans le sélénium:

Pour répliquer l'opération de clic contextuel ou de clic droit via la souris, nous devons exécuter la méthode de clic contextuel via la classe Actions dans Selenium et nous pouvons le faire dans l'approche ci-dessous: 

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());
   }
}

Pour les commandes détaillées d'Advance Selenium webdriver, visitez ici. Aussi pour comprendre la classe Actions dans Selenium et ses implémentations, visitez ici.

FAQ critiques: 

Qu'est-ce que manage () dans Selenium?

driver.manage () renvoie une référence d'implémentation de l'interface WebDriver.Options. L'interface d'Options est une interface de gestion et de gestion des actions dans un menu de navigateur telles que: 

  • ajouter un cookie
  • supprimerCookie
  • obtenir des cookies
  • Opérations de fenêtre

Pour des ensembles exhaustifs de Questions d'entretien sur le sélénium - Les ensembles critiques et avancés sont ici.

Conclusion:

Dans cette section du didacticiel, nous avons couvert le Basic Webdriver Selenium commandes, cliquez ici pour apprendre les Commandes du pilote Web Selenium intermédiaire et avancé. Pour apprendre Selenium from Scratch, cliquez ici.

À propos de Debarghya

Moi-même Debarghya Roy, je suis un ARCHITECTE en ingénierie travaillant avec la société fortune 5 et un contributeur open source, ayant environ 12 ans d'expérience / expertise dans diverses piles technologiques.
J'ai travaillé avec diverses technologies telles que 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, automatisation de l'ingénierie des processus, automatisation mainframe, développement back-end avec SpringBoot, Kafka, Redis, RabitMQ, pile ELK, GrayLog, Jenkins et ayant également une expérience dans les technologies cloud, DevOps, etc.
Je vis à Bangalore, en Inde avec ma femme et j'ai une passion pour les blogs, la musique, jouer de la guitare et ma philosophie de vie est l'éducation pour tous qui a donné naissance à LambdaGeeks. Permet de se connecter via linked-in - https://www.linkedin.com/in/debarghya-roy/

Laisser un commentaire

Votre adresse email n'apparaîtra pas. Les champs obligatoires sont marqués *

Geeks Lambda