GetServicePath should perform a scan

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 740 matching lines @@
 
     Returns:
       a dictionary of items from private_tests_info.txt
     """
     private_file = os.path.join(
         PyUITest.DataDir(), 'pyauto_private', 'private_tests_info.txt')
     assert os.path.exists(private_file), '%s missing' % private_file
     return PyUITest.EvalDataFrom(private_file)
 
   def WaitUntil(self, function, timeout=-1, retry_sleep=0.25, args=[],
-                expect_retval=None, debug=True):
+                expect_retval=None, keep_retval=False, debug=True):
     """Poll on a condition until timeout.
 
     Waits until the |function| evalues to |expect_retval| or until |timeout|
     secs, whichever occurs earlier.
 
     This is better than using a sleep, since it waits (almost) only as much
     as needed.
 
     WARNING: This method call should be avoided as far as possible in favor
     of a real wait from chromium (like wait-until-page-loaded).
@@ skipping 12 matching lines @@
                action is to wait for kWaitForActionMaxMsec, as set in
                ui_test.cc
                Use None to wait indefinitely.
       retry_sleep: the sleep interval (in secs) before retrying |function|.
                    Defaults to 0.25 secs.
       args: the args to pass to |function|
       expect_retval: the expected return value for |function|. This forms the
                      exit criteria. In case this is None (the default),
                      |function|'s return value is checked for truth,
                      so 'non-empty-string' should match with True
+      keep_retval: Boolean indicating whether to return the retval of the last
+                   iteration of |function| that succeeded without a timeout, or
+                   True.
       debug: if True, displays debug info at each retry.
 
     Returns:
-      True, if returning when |function| evaluated to True
+      The return value of the calling function when |function| evaluates to True
+          and the keep_retval is True, or True when keep_retval is false.
       False, when returning due to timeout
     """
     if timeout == -1:  # Default
       timeout = self.action_max_timeout_ms() / 1000.0
     assert callable(function), "function should be a callable"
     begin = time.time()
     debug_begin = begin
     while timeout is None or time.time() - begin <= timeout:
       retval = function(*args)
-      if (expect_retval is None and retval) or expect_retval == retval:
-        return True
+      if (expect_retval is None and retval) or \
+         (expect_retval is not None and expect_retval == retval):
+        return {True: retval, False: True}[keep_retval]

[Nirnimesh, 2012/08/08 19:51:13]

I think it'll be fine if you just return retval here (ie don't add the option in
line 761). The truth value still evaluates to True, so users will continue to
work

[stanleyw, 2012/08/08 21:38:35]

Done.

       if debug and time.time() - debug_begin > 5:
         debug_begin += 5
         if function.func_name == (lambda: True).func_name:
           function_info = inspect.getsource(function).strip()
         else:
           function_info = '%s()' % function.func_name
         logging.debug('WaitUntil(%s:%d %s) still waiting. '
                       'Expecting %s. Last returned %s.',
                       os.path.basename(inspect.getsourcefile(function)),
                       inspect.getsourcelines(function)[1],
@@ skipping 4352 matching lines @@
 
     Returns:
       The SSID of the connected network or None if we're not connected.
     """
     service_list = self.GetNetworkInfo()
     connected_service_path = service_list.get('connected_wifi')
     if 'wifi_networks' in service_list and \
        connected_service_path in service_list['wifi_networks']:
        return service_list['wifi_networks'][connected_service_path]['name']
 
-  def GetServicePath(self, ssid):
-    """Returns the service path associated with an SSID.
+  def GetServicePath(self, ssid, encryption=None, timeout=30):
+    """Waits until the SSID is observed and returns its service path.
 
     Args:
       ssid: String defining the SSID we are searching for.
+      encryption: Encryption type of the network; either None to return the
+                  first instance of network that matches the ssid, '' for
+                  an empty network, 'PSK', 'WEP' or '8021X'.
+      timeout: Duration to wait for ssid to appear.
 
     Returns:
-      The service path or None if SSID does not exist.
+      The service path or None if SSID does not exist after timeout period.
     """
-    service_list = self.GetNetworkInfo()
-    service_list = service_list.get('wifi_networks', [])
-    for service_path, service_obj in service_list.iteritems():
-      if service_obj['name'] == ssid:
-        return service_path
-    return None
+    def _get_service_path():
+      service_list = self.GetNetworkInfo().get('wifi_networks', [])
+      for service_path, service_obj in service_list.iteritems():
+        service_encr = 'PSK' if service_obj['encryption'] in ['WPA', 'RSN'] \
+                       else service_obj['encryption']
+
+        if service_obj['name'] == ssid and \
+           (encryption == None or service_encr == encryption):
+          return service_path
+      self.NetworkScan()
+      return None
+
+    service_path = self.WaitUntil(_get_service_path, keep_retval=True,
+                                  timeout=timeout, retry_sleep=1)
+    return service_path or None
 
   def NetworkScan(self):
     """Causes ChromeOS to scan for available wifi networks.
 
     Blocks until scanning is complete.
 
     Returns:
       The new list of networks obtained from GetNetworkInfo().
 
     Raises:
@@ skipping 1453 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()