Review waitUntil implementation

Author: dprevost-LMI

src/util/waitUntil.ts

@@ -5,11 +5,11 @@ const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms))
 export type ConditionResult = { success: boolean; results: boolean[] }
 
 /**
- * Wait for condition result to succeed (true) even when isNot is also true.
+ * Wait for condition result to succeed (true) or to fail (false) when using `.not`.
  * For a success result with isNot the condition must return false since Jest's expect inverts the result later.
  *
  * @param condition function
- * @param isNot     https://jestjs.io/docs/expect#thisisnot
+ * @param isNot     when using `expect().not`, see https://jestjs.io/docs/expect#thisisnot
  * @param options   wait, interval
  */
 export const waitUntil = async (
@@ -22,14 +22,24 @@ export const waitUntil = async (
     const start = Date.now()
     let error: unknown
     let result: boolean | ConditionResult = false
+    let pass: boolean = false
 
     do {
         try {
             result = await condition()
             error = undefined
-            if (isBoolean(result) ? result : result.success) {
+            if (isBoolean(result)) {
+                pass = result
+            } else {
+                // Waiting for all to be true. Or all to be false when using `.not` (pass=false since inverted later by Jest)
+                pass = isNot ? !isAllFalse(result.results) : isAllTrue(result.results)
+            }
+
+            // Waiting for the condition to succeed or to fail when using `.not`
+            if (isNot ? !pass : pass) {
                 break
             }
+
         } catch (err) {
             error = err
         }
@@ -42,19 +52,13 @@ export const waitUntil = async (
 
     if (error) { throw error }
 
-    if (isBoolean(result)) {
-        return result
-    }
-
-    const { results } = result
-
-    if (results.length === 0) {
-        // To fails with .not, we need pass=true, so it s inverted later by Jest's expect framework
+    // When no results were found, ensure the waitUntil return failure even with `.not`
+    if (!isBoolean(result) && result.results.length === 0) {
+        // To fails with .not, we need pass=true, so it's inverted later by Jest's expect framework
         return isNot
     }
 
-    // With isNot to succeed with need pass=false, so it s inverted later by Jest's expect framework
-    return isNot ? !isAllFalse(results) : isAllTrue(results)
+    return pass
 }
 const isBoolean = (value: unknown): value is boolean => typeof value === 'boolean'
 

test/matchers/element/toBeDisabled.test.ts

@@ -252,6 +252,8 @@ Expect $$(\`sel\`) not to be disabled
 
         test('not - success (with wait) - pass should be false', async () => {
             elements.forEach(element => {
+                vi.mocked(element.isEnabled).mockResolvedValueOnce(false)
+                vi.mocked(element.isEnabled).mockResolvedValueOnce(false)
                 vi.mocked(element.isEnabled).mockResolvedValue(true)
             })
 
@@ -261,9 +263,8 @@ Expect $$(\`sel\`) not to be disabled
                 wait: 500,
                 interval: 100,
             })
-            elements.forEach(element => {
-                expect(element.isEnabled).toHaveBeenCalledTimes(5)
-            })
+            expect(elements[0].isEnabled).toHaveBeenCalledTimes(3)
+            expect(elements[1].isEnabled).toHaveBeenCalledTimes(3)
             expect(result.pass).toBe(false) // success, boolean is inverted later because of `.not`
         })