Added a new PyAuto method WaitForDomNode() which allows tests to block until a specified node exist…

chrome/test/pyautolib/pyauto.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """PyAuto: Python Interface to Chromium's Automation Proxy.
 
 PyAuto uses swig to expose Automation Proxy interfaces to Python.
 For complete documentation on the functionality available,
 run pydoc on this file.
@@ skipping 2957 matching lines @@
 
   def AddDomMutationObserver(self, mutation_type, selector,
                              expected_value=None, automation_id=44444,
                              **kwargs):
     """Sets up an event observer watching for a specific DOM mutation.
 
     Creates an observer that raises an event when a mutation of the given type
     occurs on a DOM node specified by |selector|.
 
     Args:
-      mutation_type: One of 'add', 'remove', or 'change'.
+      mutation_type: One of 'add', 'remove', 'change', or 'exists'.
       selector: A DOMSelector object defining the DOM node to watch. The node
           must already exist if |mutation_type| is 'change'.
       expected_value: Optional regular expression to match against the node's
           textContent attribute after the mutation. Defaults to None.
       automation_id: The automation_id used to route the observer javascript
           messages. Defaults to 44444.
 
       Any additional keyword arguments are passed on to ExecuteJavascript and
       can be used to select the tab where the DOM MutationObserver is created.
 
     Returns:
       The id of the created observer, which can be used with GetNextEvent(id)
       and RemoveEventObserver(id).
 
     Raises:
       pyauto_errors.JSONInterfaceError if the automation call returns an error.
       RuntimeError if the injected javascript MutationObserver returns an error.
     """
-    assert mutation_type in ('add', 'remove', 'change'), \
+    assert mutation_type in ('add', 'remove', 'change', 'exists'), \
         'Unexpected value "%s" for mutation_type.' % mutation_type
     assert isinstance(selector, domselector.DOMSelector), \
         'Unexpected type: selector is not a instance of DOMSelector.'
     assert '"' not in selector.pattern, \
         'Do not use character " in selector.'
     assert not expected_value or '"' not in expected_value, \
         'Do not use character " in expected_value.'
     cmd_dict = {
       'command': 'AddDomEventObserver',
       'event_name': '__dom_mutation_observer__:$(id)',
       'automation_id': automation_id,
       'recurring': False,
     }
     observer_id = (
         self._GetResultFromJSONRequest(cmd_dict, windex=None)['observer_id'])
     jsfile = os.path.join(os.path.abspath(os.path.dirname(__file__)),
                           'dom_mutation_observer.js')
     with open(jsfile, 'r') as f:
       js = ('(' + f.read() + ')(%d, %d, "%s", "%s", "%s", %s);' %
             (automation_id, observer_id, mutation_type,
              selector.pattern, selector.type_string,
              'null' if expected_value is None else '"%s"' % expected_value))
     jsreturn = self.ExecuteJavascript(js, **kwargs)
     if jsreturn != 'success':
       self.RemoveEventObserver(observer_id)
       raise RuntimeError(jsreturn)
     return observer_id
 
+  def WaitForDomNode(self, selector, expected_value=None, timeout=-1, **kwargs):
+    """Waits until a node matching selector exists in the DOM.
+
+    NOTE: This does NOT poll. It returns as soon as the node appears, or
+      immediately if the node already exists.
+
+    Args:
+      selector: A DOMSelector object defining the DOM node to wait for.
+      expected_value: Optional regular expression to match against the node's
+          textContent attribute. Defaults to None.
+      timeout: Time to wait for the node to exist before raising an exception,
+          defaults to the default automation timeout.
+
+      Any additional keyword arguments are passed on to ExecuteJavascript and
+      can be used to select the tab where the DOM MutationObserver is created.
+
+    Raises:
+      pyauto_errors.JSONInterfaceError if the automation call returns an error.
+      RuntimeError if the injected javascript MutationObserver returns an error.

[frankf, 2012/04/16 23:53:07]

nit: RuntimeError is mostly a 'relic', think about using something else or
create your own.

[craigdh, 2012/04/16 23:58:40]

Done.

+    """
+    observer_id = self.AddDomMutationObserver('exists', selector,
+                                              expected_value, **kwargs)
+    self.GetNextEvent(observer_id, timeout=timeout)
+
   def GetNextEvent(self, observer_id=-1, blocking=True, timeout=-1):
     """Waits for an observed event to occur.
 
     The returned event is removed from the Event Queue. If there is already a
     matching event in the queue it is returned immediately, otherwise the call
     blocks until a matching event occurs. If blocking is disabled and no
     matching event is in the queue this function will immediately return None.
 
     Args:
       observer_id: The id of the observer to wait for, matches any event by
@@ skipping 2312 matching lines @@
     successful = result.wasSuccessful()
     if not successful:
       pyauto_tests_file = os.path.join(self.TestsDir(), self._tests_filename)
       print >>sys.stderr, 'Tests can be disabled by editing %s. ' \
                           'Ref: %s' % (pyauto_tests_file, _PYAUTO_DOC_URL)
     sys.exit(not successful)
 
 
 if __name__ == '__main__':
   Main()