Waiting on elements to appear using While Loops

Timing is everything. Certainly so when it comes to automation and waiting for elements to appear before moving on to the next step. While Katalon has several wait methods, including the new smart wait, there are times when you have to wait for a text change. In this case, we aren't waiting for an object, we are waiting for a condition to change. For example, we need the number of search results to increase or decrease. Or we already have a list of names, but the one we want isn't available yet.

In these cases we will use the while loop to get our status and add a delay until what we are searching for is available.

In the example below, we are waiting for a status change. We have previously created an item and now we need for the status to show as "Sold." When that happens, we can proceed with the next step.

The first thing we need to do is search for our item and read the status. If it already shows as "Sold," we can move on. If not, we reset our search criteria and search for the item again. We also add a 1 second delay. We keep repeating this until we get our "Sold" status.

itemStatus = WebUI.getText(findTestObject('select-Status Action'))
while (itemStatus.contains("Sold")!=true){
    //If the item is not set to Sold, search for it again to refresh the results
    WebUI.setText(findTestObject('input-Search Name'), GlobalVariable.itemList)
    WebUI.click(findTestObject('btn-Go Search'))
    WebUI.click(findTestObject('btn-Filter-All'))
    WebUI.delay(1)
    itemStatus = WebUI.getText(findTestObject('select-Status Action'))
}

This will certainly work, but there's a problem. If the status doesn't change, we have an endless loop. What we need is to check the condition and implement a counter. We can then check that our condition is met AND we haven't tried too many time. This can be done using the AND (&&) as part of our loop.

In this case, if we don't find the user name AND we try 20 times, it's time to bail out and fail the test.

In the example below, we are searching for a user. Since we already have a table of names, we can't wait for an element, because it's already visible. We also can't assume the first name we is correct since it may not have changed correctly and we will get a false positive.

We read the first name in the list to see if it's the one we want. If not, we add a delay of 1 second, then read the name again.

Additionally, we have added a counter that will increment up to 20 times. This equates to 20 seconds, which should be more than enough time for the name to appear.

If for some reason it doesn't, we won't be able to proceed, so the test is marked as Failed and stopped.

    //User Name in column 1, User Role in column 5
    userName=WebUI.getText(findTestObject('table-User Role Details', [('row') : 1, ('column') : 1]))
    while(userName!=GlobalVariable.UserName && counter<=20) {
        if (counter>=20){
            log.logError('ERROR: Login and User Name DO NOT match')
            log.logError('Could not find user: ' + GlobalVariable.UserName)
            KeywordUtil.markFailedAndStop('ERROR: Login and User Name DO NOT match')
        }
        WebUI.delay(1)
        userName=WebUI.getText(findTestObject('table-User Role Details', [('row') : 1, ('column') : 1]))
        counter++
    }

These are simple examples, but they show the process of waiting for something to change that isn't based on elements. In many cases, the page is loaded, we just need to wait for a certain piece of information to change. This is better than a forced delay WebUI.delay(1) because we can still have a dynamic test.

In one run it might take only a second for the status to change. In another run it might take 5 or even 10 seconds for the change to occur. With the while loop, we can handle both without the test waiting when the condition is actually correct.