Fix waitUntil not working with async/await. (#4123)

---------

Co-authored-by: Priyansh Garg <priyanshgarg30@gmail.com>

lib/api/_loaders/_command-loader.js

@@ -34,8 +34,9 @@ class BaseCommandLoader extends BaseLoader {
     const redact = this.module.RedactParams || false;
     const alwaysAsync = this.module.alwaysAsync || false;
     const isTraceable = this.module.isTraceable;
+    const avoidPrematureParentNodeResolution = !!this.module.avoidPrematureParentNodeResolution;
 
-    return {redact, alwaysAsync, isTraceable};
+    return {redact, alwaysAsync, isTraceable, avoidPrematureParentNodeResolution};
   }
 
   validateMethod(parent) {
@@ -75,7 +76,7 @@ class BaseCommandLoader extends BaseLoader {
   }
 
   getTargetNamespace(parent) {
-    let namespace = this.namespace;
+    const namespace = this.namespace;
 
     if (!parent) {
       return namespace;

lib/api/protocol/waitUntil.js

@@ -61,6 +61,10 @@ module.exports = class WaitUntil extends ProtocolAction {
     return true;
   }
 
+  static get avoidPrematureParentNodeResolution() {
+    return true;
+  }
+
   //timeMs, retryInterval, message, callback = function(r) {return r}
   async command(conditionFn, ...args) {
     let callback = function(r) {return r};

lib/core/asynctree.js

@@ -91,6 +91,18 @@ class AsyncTree extends EventEmitter{
     return parentNode.childNodes.filter(item => item !== node && !item.done).length > 0;
   }
 
+  shouldAvoidParentNodeResolution(node) {
+    const parentNode = node.parent;
+
+    if (!parentNode || parentNode.isRootNode) {
+      return true;
+    }
+
+    const result = parentNode.options?.avoidPrematureParentNodeResolution;
+
+    return Boolean(result);
+  }
+
   shouldRejectNodePromise(err, node = this.currentNode) {
     if ((err.isExpect || node.namespace === 'assert') && this.currentNode.isES6Async) {
       return true;
@@ -183,13 +195,14 @@ class AsyncTree extends EventEmitter{
 
     setTimeout(() => {
       const stillInProgress = this.otherChildNodesInProgress(node);
+      const avoidPrematureParentNodeResolution = this.shouldAvoidParentNodeResolution(node);
 
       if (node.context && node.context instanceof EventEmitter) {
         node.context.emit('complete');
       }
 
       const isAssertion = node.parent && (node.parent.namespace === 'assert' || node.parent.namespace === 'verify');
-      if (node.parent && !node.parent.isRootNode && !isAssertion && !stillInProgress) {
+      if (node.parent && !node.parent.isRootNode && !isAssertion && !stillInProgress && !avoidPrematureParentNodeResolution) {
         node.done = true;
         this.resolveNode(node.parent, result, ++times);
       }