Update to test scripts to work with both ModemManager and Cromo

test/mm.py

 #!/usr/bin/python
 
-# Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
+# Copyright (c) 2011 The Chromium OS Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import dbus
 import os
 
+MMPROVIDERS = [ 'org.chromium', 'org.freedesktop' ]
+
 class ModemManager(object):
-  MMPROVIDER = os.getenv('MMPROVIDER')
-  if not MMPROVIDER:
-    MMPROVIDER = 'org.chromium'
-  SERVICE = '%s.ModemManager' % (MMPROVIDER)
-  PATH = '/%s/ModemManager' % (MMPROVIDER.replace('.', '/'))
   INTERFACE = 'org.freedesktop.ModemManager'
   MODEM_INTERFACE = 'org.freedesktop.ModemManager.Modem'
   SIMPLE_MODEM_INTERFACE = 'org.freedesktop.ModemManager.Modem.Simple'
   CDMA_MODEM_INTERFACE = 'org.freedesktop.ModemManager.Modem.Cdma'
   GSM_MODEM_INTERFACE = 'org.freedesktop.ModemManager.Modem.Gsm'
   GOBI_MODEM_INTERFACE = 'org.chromium.ModemManager.Modem.Gobi'
   GSM_CARD_INTERFACE = 'org.freedesktop.ModemManager.Modem.Gsm.Card'
   GSM_NETWORK_INTERFACE = 'org.freedesktop.ModemManager.Modem.Gsm.Network'
   PROPERTIES_INTERFACE = 'org.freedesktop.DBus.Properties'
 
   GSM_MODEM = 1
   CDMA_MODEM = 2
 
-  def __init__(self):
+  def __init__(self, provider=None):
     self.bus = dbus.SystemBus()
-    self.manager = dbus.Interface(self.bus.get_object(ModemManager.SERVICE,
-                                                      ModemManager.PATH),
+    self.provider = provider or os.getenv('MMPROVIDER') or 'org.chromium'
+    self.service = '%s.ModemManager' % self.provider
+    self.path = '/%s/ModemManager' % (self.provider.replace('.', '/'))
+    self.manager = dbus.Interface(self.bus.get_object(self.service, self.path),
                                   ModemManager.INTERFACE)
 
   def Modem(self, path):
-    obj = self.bus.get_object(ModemManager.SERVICE, path)
+    obj = self.bus.get_object(self.service, path)
     return dbus.Interface(obj, ModemManager.MODEM_INTERFACE)
 
   def SimpleModem(self, path):
-    obj = self.bus.get_object(ModemManager.SERVICE, path)
+    obj = self.bus.get_object(self.service, path)
     return dbus.Interface(obj, ModemManager.SIMPLE_MODEM_INTERFACE)
 
   def CdmaModem(self, path):
-    obj = self.bus.get_object(ModemManager.SERVICE, path)
+    obj = self.bus.get_object(self.service, path)
     return dbus.Interface(obj, ModemManager.CDMA_MODEM_INTERFACE)
 
   def GobiModem(self, path):
-    obj = self.bus.get_object(ModemManager.SERVICE, path)
+    obj = self.bus.get_object(self.service, path)
     return dbus.Interface(obj, ModemManager.GOBI_MODEM_INTERFACE)
 
   def GsmModem(self, path):
-    obj = self.bus.get_object(ModemManager.SERVICE, path)
+    obj = self.bus.get_object(self.service, path)
     return dbus.Interface(obj, ModemManager.GSM_MODEM_INTERFACE)
 
   def GsmCard(self, path):
-    obj = self.bus.get_object(ModemManager.SERVICE, path)
+    obj = self.bus.get_object(self.service, path)
     return dbus.Interface(obj, ModemManager.GSM_CARD_INTERFACE)
 
   def GsmNetwork(self, path):
-    obj = self.bus.get_object(ModemManager.SERVICE, path)
+    obj = self.bus.get_object(self.service, path)
     return dbus.Interface(obj, ModemManager.GSM_NETWORK_INTERFACE)
 
   def GetAll(self, iface, path):
-    obj = self.bus.get_object(ModemManager.SERVICE, path)
+    obj = self.bus.get_object(self.service, path)
     obj_iface = dbus.Interface(obj, ModemManager.PROPERTIES_INTERFACE)
     return obj_iface.GetAll(iface)
 
   def GetModemInterfaces(self):
     return [
         ModemManager.MODEM_INTERFACE,
         ModemManager.SIMPLE_MODEM_INTERFACE,
         ModemManager.CDMA_MODEM_INTERFACE,
         ModemManager.GSM_MODEM_INTERFACE,
         ModemManager.GOBI_MODEM_INTERFACE]
 
   def Properties(self, path):
     props = dict()
     for iface in self.GetModemInterfaces():
       try:
         d = self.GetAll(iface, path)
       except:
         continue
       if d:
         for k, v in d.iteritems():
           props[k] = v
 
     return props
 
-def PickOneModem(manager, modem_pattern):
-  devices = manager.manager.EnumerateDevices()
-  matches = [path for path in devices if modem_pattern in path]
-  if not len(matches):
+
+def EnumerateDevices(manager=None):
+  """ Enumerate all modems in the system
+
+  Args:
+    manager - the specific manager to use, if None check all known managers
+
+  Returns:
+    a list of (ModemManager object, modem dbus path)
+  """
+  if manager:
+    managers = [manager]
+  else:
+    managers = [ModemManager(x) for x in MMPROVIDERS]
+
+  result = []
+  for m in managers:
+    for path in m.manager.EnumerateDevices():
+      result.append((m, path))
+
+  return result
+
+
+def PickOneModem(modem_pattern, manager=None):
+  """ Pick a modem
+
+  If a machine has a single modem, managed by one one of the
+  MMPROVIDERS, return the dbus path and a ModemManager object for
+  that modem.
+
+  Args:
+    modem_pattern - pattern that should match the modem path
+    manager - the specific manager to use, if None check all known managers
+
+  Returns:
+    ModemManager object, modem dbus path
+
+  Raises:
+    ValueError - if there are no matching modems, or there are more
+                 than one
+  """
+  devices = EnumerateDevices(manager)
+
+  matches = [(m, path) for m, path in devices if modem_pattern in path]
+  if not matches:
     raise ValueError("No modems had substring: " + modem_pattern)
   if len(matches) > 1:
-    raise ValueError("Expected only one modem, got: " + ', '.join(matches))
+    raise ValueError("Expected only one modem, got: " +
+                     ", ".join([path for _, path in matches]))
   return matches[0]