Le sélénium Sélectionnez - Sélection d'une option de liste déroulante de la partie du texte

La classe Le Sélénium Sélectionnez a 3 méthodes de différentes option de sélection:

selectByIndex
selectByValue
selectByVisibleText

Maintenant, j'ai une situation où je veux sélectionner une option par le texte qui partiellement apparaître dans l'un des options de texte visible (ne veux pas m'exposer à des changements dans l'ENSEMBLE du texte).

Par exemple:

<option value="0" label="not-intresting">VERY-LONG-TEXT-THAT-I-NEED-TO-SELECT-DOLLAR</option>

Et je veux sélectionner cette option uniquement en fournissant le "DOLLAR", quelque chose comme:

select.selectByPartOfVisibleText("DOLLAR")

Comment voulez-vous mettre en œuvre efficacement?

Si seulement partielle du texte est visible et vous pouvez utiliser les regex alors le voir, cette question - stackoverflow.com/questions/28817563/...

InformationsquelleAutor Johnny | 2015-04-21

4

Vous pouvez essayer une logique comme cela, espérons que cette aide
```
    List <WebElements> optionsInnerText= driver.findElements(By.tagName("option"));

     for(WebElement text: optionsInnerText){

    String textContent = text.getAttribute("textContent");

    if(textContent.toLowerCase.contains(expectedText.toLowerCase))

           select.selectByPartOfVisibleText(expectedText);
    }
```
- Cela peut fonctionner si l'option avait la text-content attribut, mais dans le cas des OP cas, il ne le fait pas.
- Inspecter l'Élément et afficher le Panneau de DOM, vous trouverez tous les attributs, y compris textContent
- Merci, c'est quelque chose comme ce que j'avais besoin. Seulement au lieu de texte.getAttribute("textContent") de la partie je pense élément.getText doit être utilisé.
InformationsquelleAutor Zach

Ma solution est d'utiliser xpath pour trouver des options qui sont les enfants de la sélectionner. Tout xpath méthode peut être utilisée pour trouver la sélection; dans cet exemple, je viens de trouver le sélectionner par id.

List<WebElement> options = driver.findElements(By.xpath("//select[@id = 'selectId')]/option"));

for (WebElement option : options) {
    if (option.getText().contains("DOLLAR")) {
        option.click();
        break;
    }
}

Après un peu plus de réflexion je me rends compte de l'option peut être trouvée entièrement avec xpath:

driver.findElements(By.xpath("//select[@id = 'selectId')]/option[contains(text(), 'DOLLAR')]")).click();

InformationsquelleAutor Cash_m

1

À L'Aide De Java 8 Stream/Lambda:
```
protected void selectOptionByPartText(WebElement elementAttr, String partialText) {
        Select select = new Select(elementAttr);
        select.getOptions().parallelStream().filter(option -> option.getAttribute("textContent").toLowerCase().contains(partialText.toLowerCase()))
                .findFirst().ifPresent(option -> select.selectByVisibleText(option.getAttribute("textContent")));
    }
```
- Fonctionne très bien. Bien que si vous ne voulez pas filtrer à travers toutes les options sur la page, et vous voulez juste de recherche interne du texte, vous pouvez essayer: protected void selectOptionByPartText(WebElement select, String partialText) { Select s = new Select(select); s.getOptions() .stream() .filter(option -> option.getText().toLowerCase().contains(partialText.toLowerCase())) .findFirst() .ifPresent(option -> s.selectByValue(option.getAttribute("value"))); }
- vous avez raison, la mise à jour de ma réponse
InformationsquelleAutor Šaikat

Obtenir une liste de tous les option valeurs et de vérifier ensuite si la valeur contient votre texte partiel. Quelque chose comme ceci:

List<WebElement> list = driver.findElements(By.tagName("option"));
Iterator<WebElement> i = list.iterator();
while(i.hasNext()) {
    WebElement wel = i.next();    
    if(wel.getText().contains("your partial text"))
    {
       //select this option
    }
}

Cool, merci. Je n'ai pas vraiment aimé travailler explicitement avec les Itérateurs, va le faire un peu différemment.

InformationsquelleAutor LittlePanda

Finalement, j'ai combiné les réponses ici et voilà le résultat:

public void selectByPartOfVisibleText(String value) {
    List<WebElement> optionElements = driver.findElement(By.cssSelector("SELECT-SELECTOR")).findElements(By.tagName("option"));

    for (WebElement optionElement: optionElements) {
        if (optionElement.getText().contains(value)) {
            String optionIndex = optionElement.getAttribute("index");
            select.electByIndex(Integer.parseInt(optionIndex));
            break;
        }
    }

    Thread.sleep(300);
}

Et dans Scala (besoin, éventuellement, à la Scala), il ressemble:

  def selectByPartOfVisibleText(value: String) = {
    val optionElements: util.List[WebElement] = selectElement.findElements(By.tagName("option"))

    breakable {
      optionElements.foreach { elm =>
        if (elm.getText.contains(value)) {
          val optionIndex = elm.getAttribute("index")
          selectByIndex(optionIndex.toInt)
          break
        }
      }
    }
    Thread.sleep(300)
  }

InformationsquelleAutor Johnny

-1

C'est ce que j'ai utilisé pour résoudre le problème en python.

J'ai utilisé cette option, il sélectionne le texte qui utilise le mot DOLLAR au lieu de taper le mot en entier comme valeur.
```
Select(driver.find_element_by_name(ELEMENT)).select_by_value("DOLLAR")
```
au lieu de
```
Select(driver.find_element_by_name(ELEMENT)).select_by_visible_text(text)
```
InformationsquelleAutor johnkerry

Vous devez vous connecter pour publier un commentaire.