Dropdown test

client-java/test-utils-java/src/main/java/org/evomaster/test/utils/SeleniumEMUtils.java

@@ -2,6 +2,7 @@
 
 import org.openqa.selenium.*;
 import org.openqa.selenium.support.ui.ExpectedCondition;
+import org.openqa.selenium.support.ui.Select;
 import org.openqa.selenium.support.ui.WebDriverWait;
 import org.testcontainers.Testcontainers;
 
@@ -127,6 +128,29 @@ public static void clickAndWaitPageLoad(WebDriver driver, String cssSelector){
         //TODO will need to check if JS executing in background
     }
 
+    public static void selectAndWaitPageLoad(WebDriver driver, String cssSelector, String value) {
+        Select element;
+        try {
+            WebElement el = driver.findElement(By.cssSelector(cssSelector));
+            element = new Select(el);
+        } catch (NoSuchElementException e) {
+            throw new RuntimeException("Cannot locate element with '" + cssSelector + "'." +
+                    "\nCurrent URL is: " + driver.getCurrentUrl() +
+                    "\nCurrent page is: " + driver.getPageSource());
+        }
+        try {
+            element.selectByValue(value);
+        } catch (NoSuchElementException e){
+            element.selectByVisibleText(value);
+        }
+
+        try {
+            Thread.sleep(50);
+        } catch (Exception e) {
+        }
+        waitForPageToLoad(driver, 2);
+    }
+
     public static void goToPage(WebDriver driver, String pageURL, int timeoutSeconds){
         driver.get(pageURL);
         waitForPageToLoad(driver, timeoutSeconds);

core-it/src/test/kotlin/org/evomaster/core/problem/webfrontend/service/BrowserControllerDockerTest.kt

@@ -19,7 +19,7 @@
         @JvmStatic
         @BeforeAll
         fun beforeAll(): Unit {
             browser.startChromeInDocker()
         }
 
         @JvmStatic
@@ -83,4 +83,49 @@
         browser.goBack()
         assertEquals(aPage, browser.getCurrentUrl())
     }
+
+    //TODO @IVa add test for Select
+    @Test
+    fun testSingleSelect(){
+        browser.initUrlOfStartingPage("http://localhost:8080/",true)
+        //browser.initUrlOfStartingPage("http://localhost:${getPort()}",true)// to double check
+        browser.goToStartingPage()
+
+        var actions = browser.computePossibleUserInteractions()
+        assertEquals(1, actions.size)
+        val homePage = browser.getCurrentUrl()
+        assertTrue(homePage.endsWith("/"), homePage)
+        val a = actions[0] // first action is the dropdown list
+        assertEquals(UserActionType.SELECT_SINGLE, a.userActionType)
+
+        browser.selectAndWaitPageLoad(a.cssSelector, listOf(a.inputs[1].toString()))
+        val page1 = browser.getCurrentUrl()
+        assertTrue(page1.endsWith("1?"), page1)// ? to be fixed
+
+        actions = browser.computePossibleUserInteractions()
+        assertEquals(1, actions.size)
+        var backHome = actions.first { it.cssSelector.contains("a") }
+        browser.clickAndWaitPageLoad(backHome.cssSelector)
+        assertEquals(homePage, browser.getCurrentUrl())
+
+        browser.selectAndWaitPageLoad(a.cssSelector, listOf(a.inputs[2].toString()))
+        val page2 = browser.getCurrentUrl()
+        assertTrue(page2.endsWith("2?"), page2)
+        actions = browser.computePossibleUserInteractions()
+        assertEquals(1, actions.size)
+        backHome = actions.first { it.cssSelector.contains("a") }
+        browser.clickAndWaitPageLoad(backHome.cssSelector)
+        assertEquals(homePage, browser.getCurrentUrl())
+
+        browser.selectAndWaitPageLoad(a.cssSelector, listOf(a.inputs[3].toString()))
+        val page3 = browser.getCurrentUrl()
+        assertTrue(page3.endsWith("3?"), page3)
+        actions = browser.computePossibleUserInteractions()
+        assertEquals(1, actions.size)
+        backHome = actions.first { it.cssSelector.contains("a") }
+        browser.clickAndWaitPageLoad(backHome.cssSelector)
+        assertEquals(homePage, browser.getCurrentUrl())
+
+    }
+
 }

core/src/main/kotlin/org/evomaster/core/output/service/WebTestCaseWriter.kt

@@ -34,7 +34,12 @@ class WebTestCaseWriter : TestCaseWriter() {
         lines.addStatement("goToPage($driver, $baseUrlOfSut, 5)")
 
         if(ind.individual is WebIndividual){
-            ind.evaluatedMainActions().forEachIndexed { index,  a ->
+            val all = ind.evaluatedMainActions()
+            for(index in all.indices) {
+                val a = all[index]
+                if(a.result.stopping){
+                    break
+                }
                 addActionLines(a.action, index, testCaseName, lines, a.result, testSuitePath, baseUrlOfSut)
             }
             val lastEvaluated = ind.evaluatedMainActions().last()
@@ -44,8 +49,10 @@ class WebTestCaseWriter : TestCaseWriter() {
                  lastResult.getUrlPageEnd()!!
             } else {
                 //if stopping, it means nothing could be done, and no info on where it went.
-                //it also implies that such entry itself was printed out in the test
-                assert(lastAction.userInteractions.isEmpty())
+                //it also implies that such entry itself was printed out in the test.
+                //however, it might be that a mutated test ends up on a page in which action is not applicable
+                //TODO should check lastAction.isApplicableInGivenPage(pageBeforeExecutingAction)
+                //assert(lastAction.userInteractions.isEmpty())
                 lastResult.getUrlPageStart()!!
             }
             lines.add(getCommentOnPage("ended on page", url,null,lastResult.getValidHtml()))
@@ -77,6 +84,11 @@ class WebTestCaseWriter : TestCaseWriter() {
                     lines.addStatement("clickAndWaitPageLoad($driver, \"${it.cssSelector}\")")
                     lines.append(getCommentOnPage("on page", r.getUrlPageStart()!!, r.getUrlPageEnd(), r.getValidHtml()))
                 }
+                UserActionType.SELECT_SINGLE-> {
+                    val selectedValue = a.singleSelection[it.cssSelector]?.getValueAsRawString() // TODO what if missing?
+                    lines.addStatement("selectAndWaitPageLoad($driver, \"${it.cssSelector}\", \"$selectedValue\")")
+                    lines.append(getCommentOnPage("on page", r.getUrlPageStart()!!, r.getUrlPageEnd(), r.getValidHtml()))
+                }
                 //TODO all other cases
                 else -> throw IllegalStateException("Not handled action type: ${it.userActionType}")
             }

core/src/main/kotlin/org/evomaster/core/problem/webfrontend/BrowserActionBuilder.kt

@@ -1,18 +1,27 @@
 package org.evomaster.core.problem.webfrontend
 
+import org.evomaster.core.search.gene.collection.EnumGene
+import org.evomaster.core.search.gene.numeric.IntegerGene
 import org.jsoup.Jsoup
+import org.jsoup.nodes.Document
+import org.openqa.selenium.By
+import org.openqa.selenium.remote.RemoteWebDriver
+import org.openqa.selenium.support.ui.Select
 import java.net.URI
 import java.net.URISyntaxException
-import java.net.URL
+import kotlin.math.min
 
 object BrowserActionBuilder {
 
 
-    fun computePossibleUserInteractions(html: String) : List<WebUserInteraction>{
+    /**
+     * Given the current page we need to see what can we do in the page, what kind of interactions we can have.
+     */
+    fun computePossibleUserInteractions(driver: RemoteWebDriver) : List<WebUserInteraction>{
 
 
         val document = try{
-            Jsoup.parse(html)
+            Jsoup.parse(driver.pageSource)
         }catch (e: Exception){
             //TODO double-check
             return listOf()
@@ -22,10 +31,52 @@ object BrowserActionBuilder {
 
         //TODO all cases
 
+        handleALinks(document, driver, list)
+        handleDropDowns(document, driver, list)
+
+        return list
+    }
+
+    private fun handleDropDowns(
+        document: Document,
+        driver: RemoteWebDriver,
+        list: MutableList<WebUserInteraction>
+    ) {
+
+        document.getElementsByTag("select")
+            .forEach { jsoup ->
+                val dropdown = Select(driver.findElement(By.cssSelector(jsoup.cssSelector())))
+                val type = if(dropdown.isMultiple) {
+                    UserActionType.SELECT_MULTI
+                }  else {
+                    UserActionType.SELECT_SINGLE
+                }
+                val options = dropdown.options
+                    .filter{it.isEnabled}
+                    .map{
+                        /*
+                            Look at "value" attribute. unfortunately, it is not mandatory.
+                            in such case, we rather use the visible text.
+                            note: prefer avoiding indices, as they are not reliable, eg, if changes, it would not
+                            break the test, unless out of bounds
+                         */
+                        it.getAttribute("value") ?: it.text
+                    }
+                list.add(WebUserInteraction(jsoup.cssSelector(), type, options))
+            }
+    }
+
+
+/* Analyze anchor tags to identify clickable elements*/
+    private fun handleALinks(
+        document: Document,
+        driver: RemoteWebDriver,
+        list: MutableList<WebUserInteraction>
+    ) {
         document.getElementsByTag("a")
             .forEach {
                 val href = it.attr("href")
-                val canClick = if(!href.isNullOrBlank()) {
+                val canClick = if (!href.isNullOrBlank()) {
                     val uri = try {
                         URI(href)
                     } catch (e: URISyntaxException) {
@@ -38,25 +89,36 @@ object BrowserActionBuilder {
                     val onclick = it.attr("onclick")
                     !onclick.isNullOrBlank()
                 }
-                if(canClick){
+                if (canClick) {
                     list.add(WebUserInteraction(it.cssSelector(), UserActionType.CLICK))
                 }
             }
-
-        return list
     }
 
 
-    fun createPossibleActions(html: String) : List<WebAction>{
+    fun createPossibleActions(driver: RemoteWebDriver) : List<WebAction>{
 
-        val interactions = computePossibleUserInteractions(html)
+        val interactions = computePossibleUserInteractions(driver)
 
         val inputs = interactions.filter { it.userActionType == UserActionType.FILL_TEXT }
         val others = interactions.filter { it.userActionType != UserActionType.FILL_TEXT }
 
         //TODO genes for inputs
 
-        return others.map { WebAction(mutableListOf(it)) }
+        return others.map {
+            when(it.userActionType) {
+                UserActionType.CLICK -> WebAction(mutableListOf(it))
+                UserActionType.SELECT_SINGLE -> {
+                    val selection = EnumGene<String>(it.cssSelector, it.inputs)
+                    WebAction(mutableListOf(it), singleSelection = mutableMapOf(it.cssSelector to selection))
+                }
+                //TODO multi
+                else -> {
+                    //TODO log warn
+                    WebAction(mutableListOf(it))
+                }
+            }
+        }
     }
 
 }

core/src/main/kotlin/org/evomaster/core/problem/webfrontend/UserActionType.kt

@@ -4,5 +4,28 @@ enum class UserActionType {
 
     CLICK,
 
-    FILL_TEXT
+    FILL_TEXT,
+
+    /**
+     * Select only a single element in a dropdown <select> element
+     */
+    SELECT_SINGLE,
+
+    /**
+     * Some dropdown <select> elements might allow to select more than one element
+     */
+    SELECT_MULTI,
+
+    DOUBLE_CLICK,
+    RIGHT_CLICK,
+    HOVER_OVER_ELEMENT,
+    VERTICAL_SCROLLING,
+    HORIZONTAL_SCROLLING,
+    DRAG_AND_DROP,
+
+    CHECK_CHECKBOX,
+    UNCHECK_CHECKBOX,
+    CHOOSE_RADIO_BUTTON,
+    SELECT,
+    UPLOAD_FILE,
 }