Adding "WaitUntilNotDisplayed"

[GHRyunosuke]

How about adding a new method of "WaitUntilNotDisplayed" which could do the following check.
BTW, the existing method of "WaitUntilNotPresent" checks if an element is presented on the web page or not, and does not care if it is displayed or not. And I ran into situations that need to WaitUntilNotDisplayed and made a function myself.

Function WaitUntilNotDisplayed(driver As WebDriver, e As WebElement, Optional maxRetriesInSeconds As Integer = 10) As Boolean
    
    On Error GoTo ErrorTrap

    Dim blnResult As Boolean: blnResult = False
    Dim retryCount As Integer
    
    If Not driver.IsDisplayed(e) Then
        blnResult = True
        GoTo ExitTrap
    End If

    For retryCount = 1 To maxRetriesInSeconds 

        sleep  1000
        If Not driver.IsDisplayed(e) Then
            blnResult = True
            GoTo ExitTrap
        End If
    
    Next retryCount
    
    If blnResult = False Then MsgBox "Taking too long for web element to not be displayed"


ExitTrap:
    WaitUntilNotDisplayed = blnResult
    Exit Function

ErrorTrap:
    MsgBox "Error " & Err.Number & " (" & Err.Description & ") in procedure: WaitUntilNotDisplayed"
    Resume ExitTrap
    
End Function

[GCuser99]

@GHRyunosuke, I think this a worthwhile addition. One question I have for you and the community...

Currently we have WaitUntilReady, which waits until the element is displayed (interactable).
If we add @GHRyunosuke's WaitUntilNotDisplayed, which is effectively waiting for the opposite condition as WaitUntilReady, then we have what could be considered an inconsistency in method names (Displayed versus Ready).

So should we:

1. Keep WaitUntilReady and add WaitUntilNotDisplayed
2. Rename WaitUntilReady to WaitUntilDisplayed and add WaitUntilNotDisplayed
3. Keep WaitUntilReady and add (renamed) WaitUntilNotReady

Anyone have a preference on how to resolve?

[GHRyunosuke]

@GCuser99 I vote for "Rename WaitUntilReady to WaitUntilDisplayed and add WaitUntilNotDisplayed", consistency is very important.
Besides, the word "Ready" is a little vague, "Displayed" is more specific and clear.

[6DiegoDiego9]

2 for me too

[GHRyunosuke]

@GCuser99
Talking about consistency what about adding "User can optionally set an implicit wait" and keep everything consistent with "IsPresent" method (i.e. we do not need a "WaitUntilIsPresent" method)?

So, it is going to be:

1. Modify "IsDisplayed" method to have "User can optionally set an implicit wait" parameter
2. Add "IsNotDispalyed" method with "User can optionally set an implicit wait"parameter
3. Remove the existing "WaitUntilNotPresent" method, adding "IsNotPrsent" with "User can optionally set an implicit wait"parameter

That way, IsPresent/IsNotPresent and IsDisplayed/IsNotDisplayed are all in line, plus great source code readability.

Further more, I even wanted the way we pass the "WebElement" parameter to be checked by the above 4 methods, to be in the same way...

[GCuser99]

@GHRyunosuke, the reason why IsPresent is structured differently than IsDisplayed is that an element object can only be valid if it is present. Or in other words, if you have a valid element object, you already know it's present. IsPresent is just a wrapper around FindElement that returns true if the element was found, hence the reason why it is structured similarly to FindElement. Whereas the IsDisplayed method applies to an element object that you already know is present. Does that make sense?

[GHRyunosuke]

Got it, so the following way of using "IsDiaplyed" is not recommended/intended (though possible). I shall first make sure the element of "By.XPath, //iframe[@title='xxxx']" exists, for example, by getting this element via "IsPresent" and then pass this element to "IsDiaplyed", right?

If .IsDisplayed(.FindElement(By.XPath, "//iframe[@title='xxxx']")) Then
...
...
End if

[GCuser99]

That example usage looks perfectly ok and makes sense to me. The .FindElement will fail if the element is not present (within the implicit wait interval). In that case IsDisplayed method does not get executed. A reason why you would want to use IsPresent in that example is if you wanted to take evasive action to avoid the error in the case where the element is not found.

If .IsPresent(By.XPath, "//iframe[@title='xxxx']",,,elemFound) Then
     If .isDisplayed(elemFound) Then
     ...
     Else
     ...
     End If
Else 'take evasive action
...
End if

[GCuser99]

I corrected my code above

[GHRyunosuke]

thanks a lot, @GCuser99 , now I fully understand those methods.
Back to the "WaitUntilNotDisplayed (or the IsPresent/IsNotPresent and IsDisplayed/IsNotDisplayed way with optionally implicit wait)" thing, I trust whatever way you decide how to handle it.

[GCuser99]

👍Ok, I'll add your WaitUntilNotDisplayed method this week.

[6DiegoDiego9]

I'm in favor of having the full set of WaitUntil and WaitUntilNot options, including WaitUntilNotPresent, even if there are relating Is or IsNot functions with the "implicit wait" parameter.

I'd also suggest centralizing the logic of the four WaitUntil and WaitUntilNot options in a new private "waitUntil" function with an argument like "UntilWhat" (string or enum), since almost all the code is the same.
Furthermore, I invite to replace the "SleepWinAPI 50 - DoEvents" pair with the new "Sleep 50", as it has the DoEvents incorporated.

[GCuser99]

@GHRyunosuke - Added WaitUntilNotDisplayed and renamed WaitUntilReady to WaitUntilDisplayed in version 5.0.

@6DiegoDiego9 - There are only three WaitUntil's - WaitUntilDisplayed, WaitUntilNotDisplayed, and WaitUntilNotPresent. There isn't a WaitUntilPresent because that functionality is handled by the Find* methods + setting implicit max wait. We certainly can add a WaitUntilPresent, but it would be somewhat functionally redundant. As far as refactoring the WaitUntil's to reduce duplicate code, I did incorporate your suggestion to replace SleepWinAPI/DoEvents with your enhanced sleep function. However, because WaitUntilNotPresent has a totally different call signature as compared to the other two, I think there is little to be gained (or saved wrt code lines) without adding unneeded complexity.

[GHRyunosuke]

@GCuser99 thanks a lot !