add GetBattorPathFromPhoneSerial to find_usb_devices

devil/devil/utils/find_usb_devices_test.py

 #!/usr/bin/env python
 # Copyright 2016 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.
 
 # pylint: disable=protected-access
 
 """
 Unit tests for the contents of find_usb_devices.py.
 
@@ skipping 15 matching lines @@
 3: Device 100 "My Test HUB" #hub 2
 3:4: Device 101 "My Test Internal HUB" #internal section of hub 2
 3:4:4: Device 102 "battor_p1_h2_t4" #physical port 1 on hub 2, on ttyusb4
 """
 
 import logging
 import unittest
 
 from devil import devil_env
 from devil.utils import find_usb_devices
+from devil.utils import usb_hubs
+from devil.utils import lsusb
 with devil_env.SysPath(devil_env.PYMOCK_PATH):
   import mock # pylint: disable=import-error
 
 # Output of lsusb.lsusb().
 # We just test that the dictionary is working by creating an
 # "ID number" equal to (bus_num*1000)+device_num and seeing if
 # it is picked up correctly. Also we test the description
 
 DEVLIST = [(1, 11, 'foo'),
            (1, 12, 'bar'),
@@ skipping 39 matching lines @@
 S:  SerialNumber=Battor2
 T:  Bus=02 Lev=00 Prnt=23 Port=03 Cnt=00 Dev#= 25 Spd=000 MxCh=00
 S:  SerialNumber=Battor3
 T:  Bus=02 Lev=00 Prnt=23 Port=02 Cnt=00 Dev#= 26 Spd=000 MxCh=00
 
 T:  Bus=02 Lev=00 Prnt=00 Port=02 Cnt=00 Dev#=100 Spd=000 MxCh=00
 T:  Bus=02 Lev=00 Prnt=100 Port=03 Cnt=00 Dev#=101 Spd=000 MxCh=00
 T:  Bus=02 Lev=00 Prnt=101 Port=03 Cnt=00 Dev#=102 Spd=000 MxCh=00
 '''
 
+RAW_LSUSB_OUTPUT = '''
+Bus 001 Device 011: FAST foo
+Bus 001 Device 012: FAST bar
+Bus 001 Device 013: baz
+Bus 002 Device 011: quux
+Bus 002 Device 020: My Test HUB
+Bus 002 Device 021: Future Technology Devices International battor_p7_h1_t0
+Bus 002 Device 022: Future Technology Devices International battor_p5_h1_t1
+Bus 002 Device 023: My Test Internal HUB
+Bus 002 Device 024: Future Technology Devices International battor_p3_h1_t2
+Bus 002 Device 025: Future Technology Devices International battor_p1_h1_t3
+Bus 002 Device 026: Not a Battery Monitor
+Bus 002 Device 100: My Test HUB
+Bus 002 Device 101: My Test Internal HUB
+Bus 002 Device 102: Future Technology Devices International battor_p1_h1_t4
+'''
+
 LIST_TTY_OUTPUT = '''
 ttyUSB0
 Something-else-0
 ttyUSB1
 ttyUSB2
 Something-else-1
 ttyUSB3
 ttyUSB4
 Something-else-2
 ttyUSB5
@@ skipping 60 matching lines @@
   with another 4-port hub connected on port 4.
   """
   if not isinstance(node, find_usb_devices.USBDeviceNode):
     return False
   if 'Test HUB' not in node.desc:
     return False
   if not node.HasPort(4):
     return False
   return 'Test Internal HUB' in node.PortToDevice(4).desc
 
-TEST_HUB = find_usb_devices.HubType(isTestHub,
-                                    {1:7,
-                                     2:6,
-                                     3:5,
-                                     4:{1:4, 2:3, 3:2, 4:1}})
+TEST_HUB = usb_hubs.HubType(isTestHub,
+                            {1:7,
+                             2:6,
+                             3:5,
+                             4:{1:4, 2:3, 3:2, 4:1}})
 
 class USBScriptTest(unittest.TestCase):
   def setUp(self):
     find_usb_devices._GetTtyUSBInfo = mock.Mock(
         side_effect=lambda x: UDEVADM_OUTPUT_DICT[x])
     find_usb_devices._GetParsedLSUSBOutput = mock.Mock(
         return_value=LSUSB_OUTPUT)
     find_usb_devices._GetUSBDevicesOutput = mock.Mock(
         return_value=USB_DEVICES_OUTPUT)
     find_usb_devices._GetCommList = mock.Mock(
         return_value=LIST_TTY_OUTPUT)
+    lsusb.raw_lsusb = mock.Mock(
+        return_value=RAW_LSUSB_OUTPUT)
 
   def testIsBattor(self):
     bd = find_usb_devices.GetBusNumberToDeviceTreeMap()
     self.assertTrue(find_usb_devices.IsBattor('ttyUSB3', bd))
     self.assertFalse(find_usb_devices.IsBattor('ttyUSB5', bd))
 
   def testGetBattors(self):
     bd = find_usb_devices.GetBusNumberToDeviceTreeMap()
     self.assertEquals(find_usb_devices.GetBattorList(bd),
                           ['ttyUSB0', 'ttyUSB1', 'ttyUSB2',
@@ skipping 21 matching lines @@
 
   def testGetSerialMapping(self):
     pp = find_usb_devices.GetAllPhysicalPortToSerialMaps([TEST_HUB])
     result = list(pp)
     self.assertEquals(result[0], {7:'Battor0',
                                   5:'Battor1',
                                   3:'Battor2',
                                   1:'Battor3'})
     self.assertEquals(result[1], {})
 
+  def testFastDeviceDescriptions(self):
+    bd = find_usb_devices.GetBusNumberToDeviceTreeMap()
+    dev_foo = bd[1].FindDeviceNumber(11)
+    dev_bar = bd[1].FindDeviceNumber(12)
+    dev_battor_p7_h1_t0 = bd[2].FindDeviceNumber(21)
+    self.assertEquals(dev_foo.desc, 'FAST foo')
+    self.assertEquals(dev_bar.desc, 'FAST bar')
+    self.assertEquals(dev_battor_p7_h1_t0.desc,
+        'Future Technology Devices International battor_p7_h1_t0')
+
   def testDeviceDescriptions(self):
-    bd = find_usb_devices.GetBusNumberToDeviceTreeMap()
+    bd = find_usb_devices.GetBusNumberToDeviceTreeMap(fast=False)
     dev_foo = bd[1].FindDeviceNumber(11)
     dev_bar = bd[1].FindDeviceNumber(12)
     dev_battor_p7_h1_t0 = bd[2].FindDeviceNumber(21)
     self.assertEquals(dev_foo.desc, 'foo')
     self.assertEquals(dev_bar.desc, 'bar')
     self.assertEquals(dev_battor_p7_h1_t0.desc,
         'Future Technology Devices International battor_p7_h1_t0')
 
   def testDeviceInformation(self):
-    bd = find_usb_devices.GetBusNumberToDeviceTreeMap()
+    bd = find_usb_devices.GetBusNumberToDeviceTreeMap(fast=False)
     dev_foo = bd[1].FindDeviceNumber(11)
     dev_bar = bd[1].FindDeviceNumber(12)
     dev_battor_p7_h1_t0 = bd[2].FindDeviceNumber(21)
     self.assertEquals(dev_foo.info['id'], 1011)
     self.assertEquals(dev_bar.info['id'], 1012)
     self.assertEquals(dev_battor_p7_h1_t0.info['id'], 2021)
 
   def testSerialNumber(self):
-    bd = find_usb_devices.GetBusNumberToDeviceTreeMap()
+    bd = find_usb_devices.GetBusNumberToDeviceTreeMap(fast=False)
     dev_foo = bd[1].FindDeviceNumber(11)
     dev_bar = bd[1].FindDeviceNumber(12)
     dev_battor_p7_h1_t0 = bd[2].FindDeviceNumber(21)
     self.assertEquals(dev_foo.serial, 'FooSerial')
     self.assertEquals(dev_bar.serial, 'BarSerial')
     self.assertEquals(dev_battor_p7_h1_t0.serial, 'Battor0')
 
+  def testBattorDictMapping(self):
+    map_dict = {'Phone1':'Battor1', 'Phone2':'Battor2', 'Phone3':'Battor3'}
+    a1 = find_usb_devices.GetBattorPathFromPhoneSerial('Phone1',
+                                                       serial_map=map_dict)
+    a2 = find_usb_devices.GetBattorPathFromPhoneSerial('Phone2',
+                                                       serial_map=map_dict)
+    a3 = find_usb_devices.GetBattorPathFromPhoneSerial('Phone3',
+                                                       serial_map=map_dict)
+    self.assertEquals(a1, '/dev/ttyUSB1')
+    self.assertEquals(a2, '/dev/ttyUSB2')
+    self.assertEquals(a3, '/dev/ttyUSB3')
+
+  def testReadSerialMapFile(self):
+    map_dict = find_usb_devices.ReadSerialMapFile(
+        'testdata/test_serial_map.json')
+    self.assertEquals(len(map_dict.keys()), 3)
+    self.assertEquals(map_dict['Phone1'], 'Battor1')
+    self.assertEquals(map_dict['Phone2'], 'Battor2')
+    self.assertEquals(map_dict['Phone3'], 'Battor3')
+
+original_PPTSM = find_usb_devices.GetAllPhysicalPortToSerialMaps
+original_PPTTM = find_usb_devices.GetAllPhysicalPortToTTYMaps
+original_GBL = find_usb_devices.GetBattorList
+original_GBNDM = find_usb_devices.GetBusNumberToDeviceTreeMap
+original_IB = find_usb_devices.IsBattor
+original_GBSM = find_usb_devices.GetBattorSerialNumbers
+
+def setup_battor_test(serial, tty, battor, bser=None):
+  serial_mapper = mock.Mock(return_value=serial)
+  tty_mapper = mock.Mock(return_value=tty)
+  battor_lister = mock.Mock(return_value=battor)
+  devtree = mock.Mock(return_value=None)
+  is_battor = mock.Mock(side_effect=lambda x, y: x in battor)
+  battor_serials = mock.Mock(return_value=bser)
+  find_usb_devices.GetAllPhysicalPortToSerialMaps = serial_mapper
+  find_usb_devices.GetAllPhysicalPortToTTYMaps = tty_mapper
+  find_usb_devices.GetBattorList = battor_lister
+  find_usb_devices.GetBusNumberToDeviceTreeMap = devtree
+  find_usb_devices.IsBattor = is_battor
+  find_usb_devices.GetBattorSerialNumbers = battor_serials
+
+class BattorMappingTest(unittest.TestCase):
+  def tearDown(self):
+    find_usb_devices.GetAllPhysicalPortToSerialMaps = original_PPTSM
+    find_usb_devices.GetAllPhysicalPortToTTYMaps = original_PPTTM
+    find_usb_devices.GetBattorList = original_GBL
+    find_usb_devices.GetBusNumberToDeviceTreeMap = original_GBNDM
+    find_usb_devices.IsBattor = original_IB
+    find_usb_devices.GetBattorSerialNumbers = original_GBSM
+
+  def test_generate_serial_map(self):
+    setup_battor_test([{1:'Phn1', 2:'Phn2', 3:'Phn3'},
+                       {1:'Bat1', 2:'Bat2', 3:'Bat3'}],
+                      [{},
+                       {1:'ttyUSB0', 2:'ttyUSB1', 3:'ttyUSB2'}],
+                      ['ttyUSB0', 'ttyUSB1', 'ttyUSB2'],
+                      ['Bat1', 'Bat2', 'Bat3'])
+    result = find_usb_devices.GenerateSerialMap()
+    self.assertEqual(len(result), 3)
+    self.assertEqual(result['Phn1'], 'Bat1')
+    self.assertEqual(result['Phn2'], 'Bat2')
+    self.assertEqual(result['Phn3'], 'Bat3')
+
+
 if __name__ == "__main__":
   logging.getLogger().setLevel(logging.DEBUG)
   unittest.main(verbosity=2)