Launchpad itself

Merge lp:~adeuring/launchpad/hwdb-class-udev-device-4 into lp:launchpad/db-devel

  1. hwdb-class-udev-device-4
  2. Merge into db-devel
Proposed by Abel Deuring
Status: Merged
Approved by: Brad Crittenden
Approved revision: no longer in the source branch.
Merged at revision: not available
Proposed branch: lp:~adeuring/launchpad/hwdb-class-udev-device-4
Merge into: lp:launchpad/db-devel
Diff against target: 664 lines
2 files modified
lib/canonical/launchpad/scripts/hwdbsubmissions.py (+157/-16)
lib/canonical/launchpad/scripts/tests/test_hwdb_submission_processing.py (+207/-58)
To merge this branch: bzr merge lp:~adeuring/launchpad/hwdb-class-udev-device-4
Reviewer Review Type Date Requested Status
Brad Crittenden (community) code Approve
Canonical Launchpad Engineering Pending
Review via email: mp+13300@code.launchpad.net
To post a comment you must log in.
Revision history for this message
Abel Deuring (adeuring) wrote :

This branch adds the properties pci_ids, raw_bus, vendor, vendor_id, product, product_id to class UdevDevice.

The HWDB client in Karmic will no longer send data gathered from HAL, but gathered from udev, supplemented by sysfs and DMI data.

The HWDB submission processing script represents devices found in the submission data in a class derived from BaseDevice; this branch is another step to complete the implementation of class UdevDevice.

I forgot in earlier branches to specify the DMI data as a parameter of the UdevDevice constructor, so this branch contains also a number of purely formal changes in the tests, where class UdevDevice is instantiated.

I also noticed that I forgot a "raise NotImplemented" for a property of class BaseDevice.

test:
./bin/test --test=test_hwdb_submission_processing

= Launchpad lint =

Checking for conflicts. and issues in doctests and templates.
Running jslint, xmllint, pyflakes, and pylint.
Using normal rules.

Linting changed files:
  lib/canonical/launchpad/scripts/hwdbsubmissions.py
  lib/canonical/launchpad/scripts/tests/test_hwdb_submission_processing.py

== Pyflakes notices ==

lib/canonical/launchpad/scripts/hwdbsubmissions.py
    22: redefinition of unused 'etree' from line 20

== Pylint notices ==

lib/canonical/launchpad/scripts/hwdbsubmissions.py
    20: [F0401] Unable to import 'xml.etree.cElementTree' (No module named etree)

The complaints about etree are not related to my changes.

Revision history for this message
Brad Crittenden (bac) wrote :
Download full text (8.8 KiB)

Hi Abel,

Thanks for the changes. We discussed some of my suggestions on IRC already. Please post an incremental diff when you've made these changes.

--Brad

> === modified file 'lib/canonical/launchpad/scripts/hwdbsubmissions.py'
> --- lib/canonical/launchpad/scripts/hwdbsubmissions.py 2009-10-12 15:36:04 +0000
> +++ lib/canonical/launchpad/scripts/hwdbsubmissions.py 2009-10-13 17:50:28 +0000
@@ -59,6 +59,7 @@
> re.VERBOSE)
>
> ROOT_UDI = '/org/freedesktop/Hal/devices/computer'
> +UDEV_ROOT_PATH = '/devices/LNXSYSTM:00'
>
> # These UDIs appears in some submissions more than once.
> KNOWN_DUPLICATE_UDIS = set((
> @@ -1606,6 +1607,7 @@
> @property
> def driver_name(self):
> """The name of the driver contolling this device. May be None."""
> + raise NotImplementedError

Nice clean up.

> def translateScsiBus(self):
> """Return the real bus of a device where raw_bus=='scsi'.
> @@ -2358,7 +2360,7 @@
> class UdevDevice(BaseDevice):
> """The representation of a udev device node."""
>
> - def __init__(self, udev_data, sysfs_data, parser):
> + def __init__(self, udev_data, sysfs_data, dmi_data, parser):
> """HALDevice constructor.

Seeing all of your test changes that required adding another parameter
make me wonder if you don't want to have default values on some of
these, especially the new one. Also I'm surprised to see you didn't
add the new on at the end, which helps with backward compatability.

> :param udevdata: The udev data for this device
> @@ -2369,6 +2371,7 @@
> super(UdevDevice, self).__init__(parser)
> self.udev = udev_data
> self.sysfs = sysfs_data
> + self.dmi = dmi_data
>
> @property
> def device_id(self):
> @@ -2410,6 +2413,24 @@
> return self.pci_class_info[1]

As we discussed on IRC, a lot of your code would be cleaner if methods
such as this one returned a dictionary with 'vendor' and 'product' as
the keys. Take a stab at doing that throughout and see what happens.

> @property
> + def pci_ids(self):
> + """The PCI vendor and product IDs.
> +
> + :return: (vendor_id, product_id) for PCI devices
> + or (None, None) for other devices.
> + """
> + if self.is_pci:
> + # SubmissionParser.checkUdevPciProperties() ensures that
> + # each PCI device has the property PCI_ID and that is
> + # consists of two 4-digit hexadecimal numbers, separated
> + # by a ':'.
> + id_string = self.udev['E']['PCI_ID']
> + ids = id_string.split(':')
> + return [int(part, 16) for part in ids]
> + else:
> + return [None, None]
> +
> + @property
> def is_usb(self):
> """True, if this is a USB device, else False."""
> return self.udev['E'].get('SUBSYSTEM') == 'usb'
> @@ -2476,6 +2497,116 @@
> else:
> return None
>
> + @property
> + def raw_bus(self):
> + """See `BaseDevice`."""
> + # udev specifies the property SUBSYSTEM for most devices;
> + # some devices have additionally the more specific property
...

Read more...

review: Needs Fixing (code)
Revision history for this message
Abel Deuring (adeuring) wrote :
Download full text (33.5 KiB)

Hi Brad,

thanks for your review.

On 13.10.2009 21:28, Brad Crittenden wrote:
> Review: Needs Fixing code
> Hi Abel,
>
> Thanks for the changes. We discussed some of my suggestions on IRC already. Please post an incremental diff when you've made these changes.
>
> --Brad
>
>
>> === modified file 'lib/canonical/launchpad/scripts/hwdbsubmissions.py'
>> --- lib/canonical/launchpad/scripts/hwdbsubmissions.py 2009-10-12 15:36:04 +0000
>> +++ lib/canonical/launchpad/scripts/hwdbsubmissions.py 2009-10-13 17:50:28 +0000
> @@ -59,6 +59,7 @@
>> re.VERBOSE)
>>
>> ROOT_UDI = '/org/freedesktop/Hal/devices/computer'
>> +UDEV_ROOT_PATH = '/devices/LNXSYSTM:00'
>>
>> # These UDIs appears in some submissions more than once.
>> KNOWN_DUPLICATE_UDIS = set((
>> @@ -1606,6 +1607,7 @@
>> @property
>> def driver_name(self):
>> """The name of the driver contolling this device. May be None."""
>> + raise NotImplementedError
>
> Nice clean up.
>
>> def translateScsiBus(self):
>> """Return the real bus of a device where raw_bus=='scsi'.
>> @@ -2358,7 +2360,7 @@
>> class UdevDevice(BaseDevice):
>> """The representation of a udev device node."""
>>
>> - def __init__(self, udev_data, sysfs_data, parser):
>> + def __init__(self, udev_data, sysfs_data, dmi_data, parser):
>> """HALDevice constructor.
>
> Seeing all of your test changes that required adding another parameter
> make me wonder if you don't want to have default values on some of
> these, especially the new one. Also I'm surprised to see you didn't
> add the new on at the end, which helps with backward compatability.

Well, class UdevDevice is yet not used anywhere, so backward
compatibility is not an issue. But you are right, dmi_data and
sysfs_data in many cases not needed, while parser _is_ needed (in class
BaseDevice), so I shuffled the parameters again...

>
>> :param udevdata: The udev data for this device
>> @@ -2369,6 +2371,7 @@
>> super(UdevDevice, self).__init__(parser)
>> self.udev = udev_data
>> self.sysfs = sysfs_data
>> + self.dmi = dmi_data
>>
>> @property
>> def device_id(self):
>> @@ -2410,6 +2413,24 @@
>> return self.pci_class_info[1]
>
> As we discussed on IRC, a lot of your code would be cleaner if methods
> such as this one returned a dictionary with 'vendor' and 'product' as
> the keys. Take a stab at doing that throughout and see what happens.

Changed. Though this made the diff a bit larger, since it affected (via
the method getScsiVendorAnModel()) also class HALDevice...

>
>> @property
>> + def pci_ids(self):
>> + """The PCI vendor and product IDs.
>> +
>> + :return: (vendor_id, product_id) for PCI devices
>> + or (None, None) for other devices.
>> + """
>> + if self.is_pci:
>> + # SubmissionParser.checkUdevPciProperties() ensures that
>> + # each PCI device has the property PCI_ID and that is
>> + # consists of two 4-digit hexadecimal numbers, separated
>> + # by a ':'.
>> + id_string = self.udev['E']['PCI_ID']
>> + ids = id...

Revision history for this message
Brad Crittenden (bac) wrote :

Thanks for the changes Abel!

review: Approve (code)

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
=== modified file 'lib/canonical/launchpad/scripts/hwdbsubmissions.py'
--- lib/canonical/launchpad/scripts/hwdbsubmissions.py 2009-10-12 15:36:04 +0000
+++ lib/canonical/launchpad/scripts/hwdbsubmissions.py 2009-10-13 21:06:13 +0000
@@ -59,6 +59,7 @@
59 re.VERBOSE)59 re.VERBOSE)
6060
61ROOT_UDI = '/org/freedesktop/Hal/devices/computer'61ROOT_UDI = '/org/freedesktop/Hal/devices/computer'
62UDEV_ROOT_PATH = '/devices/LNXSYSTM:00'
6263
63# These UDIs appears in some submissions more than once.64# These UDIs appears in some submissions more than once.
64KNOWN_DUPLICATE_UDIS = set((65KNOWN_DUPLICATE_UDIS = set((
@@ -1606,6 +1607,7 @@
1606 @property1607 @property
1607 def driver_name(self):1608 def driver_name(self):
1608 """The name of the driver contolling this device. May be None."""1609 """The name of the driver contolling this device. May be None."""
1610 raise NotImplementedError
16091611
1610 def translateScsiBus(self):1612 def translateScsiBus(self):
1611 """Return the real bus of a device where raw_bus=='scsi'.1613 """Return the real bus of a device where raw_bus=='scsi'.
@@ -2067,10 +2069,15 @@
2067 # it is hard to find a better heuristic to separate2069 # it is hard to find a better heuristic to separate
2068 # the vendor name from the product name.2070 # the vendor name from the product name.
2069 splitted_name = self.scsi_model.split(' ', 1)2071 splitted_name = self.scsi_model.split(' ', 1)
2070 if len(splitted_name) < 2:2072 if len(splitted_name) == 2:
2071 return 'ATA', splitted_name[0]2073 return {
2072 return splitted_name2074 'vendor': splitted_name[0],
2073 return (vendor, self.scsi_model)2075 'product': splitted_name[1],
2076 }
2077 return {
2078 'vendor': vendor,
2079 'product': self.scsi_model,
2080 }
20742081
2075 def getDriver(self):2082 def getDriver(self):
2076 """Return the HWDriver instance associated with this device.2083 """Return the HWDriver instance associated with this device.
@@ -2289,11 +2296,7 @@
2289 # below does not work properly.2296 # below does not work properly.
2290 return self.getProperty('system.hardware.' + type_)2297 return self.getProperty('system.hardware.' + type_)
2291 elif bus == 'scsi':2298 elif bus == 'scsi':
2292 vendor, product = self.getScsiVendorAndModelName()2299 return self.getScsiVendorAndModelName()[type_]
2293 if type_ == 'vendor':
2294 return vendor
2295 else:
2296 return product
2297 else:2300 else:
2298 result = self.getProperty('info.' + type_)2301 result = self.getProperty('info.' + type_)
2299 if result is None:2302 if result is None:
@@ -2358,7 +2361,7 @@
2358class UdevDevice(BaseDevice):2361class UdevDevice(BaseDevice):
2359 """The representation of a udev device node."""2362 """The representation of a udev device node."""
23602363
2361 def __init__(self, udev_data, sysfs_data, parser):2364 def __init__(self, parser, udev_data, sysfs_data=None, dmi_data=None):
2362 """HALDevice constructor.2365 """HALDevice constructor.
23632366
2364 :param udevdata: The udev data for this device2367 :param udevdata: The udev data for this device
@@ -2369,6 +2372,7 @@
2369 super(UdevDevice, self).__init__(parser)2372 super(UdevDevice, self).__init__(parser)
2370 self.udev = udev_data2373 self.udev = udev_data
2371 self.sysfs = sysfs_data2374 self.sysfs = sysfs_data
2375 self.dmi = dmi_data
23722376
2373 @property2377 @property
2374 def device_id(self):2378 def device_id(self):
@@ -2376,6 +2380,14 @@
2376 return self.udev['P']2380 return self.udev['P']
23772381
2378 @property2382 @property
2383 def root_device_ids(self):
2384 """The vendor and product IDs of the root device."""
2385 return {
2386 'vendor': self.dmi.get('/sys/class/dmi/id/sys_vendor'),
2387 'product': self.dmi.get('/sys/class/dmi/id/product_name')
2388 }
2389
2390 @property
2379 def is_pci(self):2391 def is_pci(self):
2380 """True, if this is a PCI device, else False."""2392 """True, if this is a PCI device, else False."""
2381 return self.udev['E'].get('SUBSYSTEM') == 'pci'2393 return self.udev['E'].get('SUBSYSTEM') == 'pci'
@@ -2410,6 +2422,30 @@
2410 return self.pci_class_info[1]2422 return self.pci_class_info[1]
24112423
2412 @property2424 @property
2425 def pci_ids(self):
2426 """The PCI vendor and product IDs.
2427
2428 :return: A dictionary containing the vendor and product IDs.
2429 The IDs are set to None for Non-PCI devices.
2430 """
2431 if self.is_pci:
2432 # SubmissionParser.checkUdevPciProperties() ensures that
2433 # each PCI device has the property PCI_ID and that is
2434 # consists of two 4-digit hexadecimal numbers, separated
2435 # by a ':'.
2436 id_string = self.udev['E']['PCI_ID']
2437 ids = id_string.split(':')
2438 return {
2439 'vendor': int(ids[0], 16),
2440 'product': int(ids[1], 16),
2441 }
2442 else:
2443 return {
2444 'vendor': None,
2445 'product': None,
2446 }
2447
2448 @property
2413 def is_usb(self):2449 def is_usb(self):
2414 """True, if this is a USB device, else False."""2450 """True, if this is a USB device, else False."""
2415 return self.udev['E'].get('SUBSYSTEM') == 'usb'2451 return self.udev['E'].get('SUBSYSTEM') == 'usb'
@@ -2418,8 +2454,9 @@
2418 def usb_ids(self):2454 def usb_ids(self):
2419 """The vendor ID, product ID, product version for USB devices.2455 """The vendor ID, product ID, product version for USB devices.
24202456
2421 :return: [vendor_id, product_id, version] for USB devices2457 :return: A dictionary containing the vendor and product IDs and
2422 or [None, None, None] for other devices.2458 the product version for USB devices.
2459 The IDs are set to None for Non-USB devices.
2423 """2460 """
2424 if self.is_usb:2461 if self.is_usb:
2425 # udev represents USB device IDs as strings2462 # udev represents USB device IDs as strings
@@ -2428,19 +2465,27 @@
2428 # SubmissionParser.checkUdevUsbProperties() ensures that2465 # SubmissionParser.checkUdevUsbProperties() ensures that
2429 # the string PRODUCT is in the format required below.2466 # the string PRODUCT is in the format required below.
2430 product_info = self.udev['E']['PRODUCT'].split('/')2467 product_info = self.udev['E']['PRODUCT'].split('/')
2431 return [int(part, 16) for part in product_info]2468 return {
2469 'vendor': int(product_info[0], 16),
2470 'product': int(product_info[1], 16),
2471 'version': int(product_info[2], 16),
2472 }
2432 else:2473 else:
2433 return [None, None, None]2474 return {
2475 'vendor': None,
2476 'product': None,
2477 'version': None,
2478 }
24342479
2435 @property2480 @property
2436 def usb_vendor_id(self):2481 def usb_vendor_id(self):
2437 """See `BaseDevice`."""2482 """See `BaseDevice`."""
2438 return self.usb_ids[0]2483 return self.usb_ids['vendor']
24392484
2440 @property2485 @property
2441 def usb_product_id(self):2486 def usb_product_id(self):
2442 """See `BaseDevice`."""2487 """See `BaseDevice`."""
2443 return self.usb_ids[1]2488 return self.usb_ids['product']
24442489
2445 @property2490 @property
2446 def is_scsi_device(self):2491 def is_scsi_device(self):
@@ -2476,6 +2521,102 @@
2476 else:2521 else:
2477 return None2522 return None
24782523
2524 @property
2525 def raw_bus(self):
2526 """See `BaseDevice`."""
2527 # udev specifies the property SUBSYSTEM for most devices;
2528 # some devices have additionally the more specific property
2529 # DEVTYPE. DEVTYPE is preferable.
2530 # The root device has the subsystem/bus value "acpi", which
2531 # is a bit nonsensical.
2532 if self.device_id == UDEV_ROOT_PATH:
2533 return None
2534 properties = self.udev['E']
2535 devtype = properties.get('DEVTYPE')
2536 if devtype is not None:
2537 return devtype
2538 return properties.get('SUBSYSTEM')
2539
2540 def getVendorOrProduct(self, type_):
2541 """Return the vendor or product of this device.
2542
2543 :return: The vendor or product data for this device.
2544 :param type_: 'vendor' or 'product'
2545 """
2546 assert type_ in ('vendor', 'product'), (
2547 'Unexpected value of type_: %r' % type_)
2548
2549 bus = self.raw_bus
2550 if self.device_id == UDEV_ROOT_PATH:
2551 # udev does not known about any product information for
2552 # the root device. We use DMI data instead.
2553 return self.root_device_ids[type_]
2554 elif bus == 'scsi_device':
2555 return self.getScsiVendorAndModelName()[type_]
2556 elif bus in ('pci', 'usb_device'):
2557 # XXX Abel Deuring 2009-10-13, bug 450480: udev does not
2558 # provide human-readable vendor and product names for
2559 # USB and PCI devices. We should retrieve these from
2560 # http://www.linux-usb.org/usb.ids and
2561 # http://pciids.sourceforge.net/v2.2/pci.ids
2562 return 'Unknown'
2563 else:
2564 # We don't process yet other devices than complete systems,
2565 # PCI, USB devices and those devices that are represented
2566 # in udev as SCSI devices: real SCSI devices, and
2567 # IDE/ATA/SATA devices.
2568 return None
2569
2570 @property
2571 def vendor(self):
2572 """See `BaseDevice`."""
2573 return self.getVendorOrProduct('vendor')
2574
2575 @property
2576 def product(self):
2577 """See `BaseDevice`."""
2578 return self.getVendorOrProduct('product')
2579
2580 def getVendorOrProductID(self, type_):
2581 """Return the vendor or product ID of this device.
2582
2583 :return: The vendor or product ID for this device.
2584 :param type_: 'vendor' or 'product'
2585 """
2586 assert type_ in ('vendor', 'product'), (
2587 'Unexpected value of type_: %r' % type_)
2588
2589 bus = self.raw_bus
2590 if self.device_id == UDEV_ROOT_PATH:
2591 # udev does not known about any product information for
2592 # the root device. We use DMI data instead.
2593 if type_ == 'vendor':
2594 return self.dmi.get('/sys/class/dmi/id/sys_vendor')
2595 else:
2596 return self.dmi.get('/sys/class/dmi/id/product_name')
2597 elif bus == 'scsi_device':
2598 return self.getScsiVendorAndModelName()[type_]
2599 elif bus == 'pci':
2600 return self.pci_ids[type_]
2601 elif bus == 'usb_device':
2602 return self.usb_ids[type_]
2603 else:
2604 # We don't process yet other devices than complete systems,
2605 # PCI, USB devices and those devices that are represented
2606 # in udev as SCSI devices: real SCSI devices, and
2607 # IDE/ATA/SATA devices.
2608 return None
2609
2610 @property
2611 def vendor_id(self):
2612 """See `BaseDevice`."""
2613 return self.getVendorOrProductID('vendor')
2614
2615 @property
2616 def product_id(self):
2617 """See `BaseDevice`."""
2618 return self.getVendorOrProductID('product')
2619
24792620
2480class ProcessingLoop(object):2621class ProcessingLoop(object):
2481 """An `ITunableLoop` for processing HWDB submissions."""2622 """An `ITunableLoop` for processing HWDB submissions."""
24822623
=== modified file 'lib/canonical/launchpad/scripts/tests/test_hwdb_submission_processing.py'
--- lib/canonical/launchpad/scripts/tests/test_hwdb_submission_processing.py 2009-10-12 14:50:22 +0000
+++ lib/canonical/launchpad/scripts/tests/test_hwdb_submission_processing.py 2009-10-13 21:06:13 +0000
@@ -1598,18 +1598,16 @@
1598 parser = SubmissionParser(self.log)1598 parser = SubmissionParser(self.log)
1599 parser.buildDeviceList(parsed_data)1599 parser.buildDeviceList(parsed_data)
1600 device = parser.hal_devices[self.UDI_SCSI_DISK]1600 device = parser.hal_devices[self.UDI_SCSI_DISK]
1601 vendor, model = device.getScsiVendorAndModelName()1601 vendor_model = device.getScsiVendorAndModelName()
1602 self.assertEqual(1602 self.assertEqual(
1603 vendor, 'SHARP',1603 {
1604 'vendor': 'SHARP',
1605 'product': 'JX250 SCSI',
1606 },
1607 vendor_model,
1604 'Unexpected result of HWDevice.getScsiVendorAndModelName '1608 'Unexpected result of HWDevice.getScsiVendorAndModelName '
1605 'for a regular SCSI device. Expected vendor name SHARP, got %r.'1609 'for a regular SCSI device. Expected vendor name SHARP, got %r.'
1606 % vendor)1610 % vendor_model)
1607 self.assertEqual(
1608 model, 'JX250 SCSI',
1609 'Unexpected result of HWDevice.getScsiVendorAndModelName '
1610 'for a regular SCSI device. Expected model name JX250 SCSI , '
1611 'got %r.'
1612 % model)
16131611
1614 def testHALDeviceSCSIVendorModelNameATADiskShortModelName(self):1612 def testHALDeviceSCSIVendorModelNameATADiskShortModelName(self):
1615 """Test of HALDevice.getScsiVendorAndModelName, ATA disk (1).1613 """Test of HALDevice.getScsiVendorAndModelName, ATA disk (1).
@@ -1639,18 +1637,16 @@
1639 parser = SubmissionParser(self.log)1637 parser = SubmissionParser(self.log)
1640 parser.buildDeviceList(parsed_data)1638 parser.buildDeviceList(parsed_data)
1641 device = parser.hal_devices[self.UDI_SCSI_DISK]1639 device = parser.hal_devices[self.UDI_SCSI_DISK]
1642 vendor, model = device.getScsiVendorAndModelName()1640 vendor_model = device.getScsiVendorAndModelName()
1643 self.assertEqual(1641 self.assertEqual(
1644 vendor, 'Hitachi',1642 {
1645 'Unexpected result of HWDevice.getScsiVendorAndModelName '1643 'vendor': 'Hitachi',
1646 'for an ATA SCSI device. Expected vendor name Hitachi, got %r.'1644 'product': 'HTS54161',
1647 % vendor)1645 },
1648 self.assertEqual(1646 vendor_model,
1649 model, 'HTS54161',1647 'Unexpected result of HWDevice.getScsiVendorAndModelName '
1650 'Unexpected result of HWDevice.getScsiVendorAndModelName '1648 'for an ATA SCSI device: %r.'
1651 'for a reguale SCSI device. Expected vendor name HTS54161, '1649 % vendor_model)
1652 'got %r.'
1653 % model)
16541650
1655 def testHALDeviceSCSIVendorModelNameATADiskLongModelName(self):1651 def testHALDeviceSCSIVendorModelNameATADiskLongModelName(self):
1656 """Test of HALDevice.getScsiVendorAndModelName, ATA disk (2).1652 """Test of HALDevice.getScsiVendorAndModelName, ATA disk (2).
@@ -1679,18 +1675,16 @@
1679 parser = SubmissionParser(self.log)1675 parser = SubmissionParser(self.log)
1680 parser.buildDeviceList(parsed_data)1676 parser.buildDeviceList(parsed_data)
1681 device = parser.hal_devices[self.UDI_SCSI_DISK]1677 device = parser.hal_devices[self.UDI_SCSI_DISK]
1682 vendor, model = device.getScsiVendorAndModelName()1678 vendor_product = device.getScsiVendorAndModelName()
1683 self.assertEqual(1679 self.assertEqual(
1684 vendor, 'ATA',1680 {
1685 'Unexpected result of HWDevice.getScsiVendorAndModelName '1681 'vendor': 'ATA',
1686 'for a reguale SCSI device. Expected vendor name ATA, got %r.'1682 'product': 'HTC426060G9AT00',
1687 % vendor)1683 },
1688 self.assertEqual(1684 vendor_product,
1689 model, 'HTC426060G9AT00',1685 'Unexpected result of HWDevice.getScsiVendorAndModelName '
1690 'Unexpected result of HWDevice.getScsiVendorAndModelName '1686 'for a reguale SCSI device: %r.'
1691 'for a reguale SCSI device. Expected vendor name '1687 % vendor_product)
1692 'HTC426060G9AT00 , got %r.'
1693 % model)
16941688
1695 def testHALDeviceVendorFromInfoVendor(self):1689 def testHALDeviceVendorFromInfoVendor(self):
1696 """Test of HALDevice.vendor, regular case.1690 """Test of HALDevice.vendor, regular case.
@@ -2606,6 +2600,11 @@
2606 }2600 }
2607 }2601 }
26082602
2603 root_device_dmi_data = {
2604 '/sys/class/dmi/id/sys_vendor': 'FUJITSU SIEMENS',
2605 '/sys/class/dmi/id/product_name': 'LIFEBOOK E8210',
2606 }
2607
2609 pci_device_data = {2608 pci_device_data = {
2610 'P': '/devices/pci0000:00/0000:00:1f.2',2609 'P': '/devices/pci0000:00/0000:00:1f.2',
2611 'E': {2610 'E': {
@@ -2641,97 +2640,149 @@
2641 'type': '5',2640 'type': '5',
2642 }2641 }
26432642
2643 no_subsystem_device_data = {
2644 'P': '/devices/pnp0/00:00',
2645 'E': {}
2646 }
2647
2644 def test_device_id(self):2648 def test_device_id(self):
2645 """Test of UdevDevice.device_id."""2649 """Test of UdevDevice.device_id."""
2646 device = UdevDevice(self.pci_device_data, None, None)2650 device = UdevDevice(None, self.pci_device_data)
2647 self.assertEqual(2651 self.assertEqual(
2648 '/devices/pci0000:00/0000:00:1f.2', device.device_id,2652 '/devices/pci0000:00/0000:00:1f.2', device.device_id,
2649 'Unexpected value of UdevDevice.device_id.')2653 'Unexpected value of UdevDevice.device_id.')
26502654
2655 def test_root_device_ids(self):
2656 device = UdevDevice(
2657 None, self.root_device, None, self.root_device_dmi_data)
2658 self.assertEqual(
2659 {
2660 'vendor': 'FUJITSU SIEMENS',
2661 'product': 'LIFEBOOK E8210',
2662 },
2663 device.root_device_ids)
2664
2665 device = UdevDevice(
2666 None, self.root_device, None, {})
2667 self.assertEqual(
2668 {
2669 'vendor': None,
2670 'product': None,
2671 },
2672 device.root_device_ids)
2673
2651 def test_is_pci(self):2674 def test_is_pci(self):
2652 """Test of UdevDevice.is_pci."""2675 """Test of UdevDevice.is_pci."""
2653 device = UdevDevice(self.pci_device_data, None, None)2676 device = UdevDevice(None, self.pci_device_data)
2654 self.assertTrue(device.is_pci)2677 self.assertTrue(device.is_pci)
26552678
2656 device = UdevDevice(self.root_device, None, None)2679 device = UdevDevice(None, self.root_device)
2657 self.assertFalse(device.is_pci)2680 self.assertFalse(device.is_pci)
26582681
2659 def test_pci_class_info(self):2682 def test_pci_class_info(self):
2660 """Test of UdevDevice.pci_class_info"""2683 """Test of UdevDevice.pci_class_info"""
2661 device = UdevDevice(self.pci_device_data, None, None)2684 device = UdevDevice(None, self.pci_device_data)
2662 self.assertEqual(2685 self.assertEqual(
2663 (1, 6, 2), device.pci_class_info,2686 (1, 6, 2), device.pci_class_info,
2664 'Invalid value of UdevDevice.pci_class_info for PCI device.')2687 'Invalid value of UdevDevice.pci_class_info for PCI device.')
26652688
2666 device = UdevDevice(self.root_device, None, None)2689 device = UdevDevice(None, self.root_device)
2667 self.assertEqual(2690 self.assertEqual(
2668 (None, None, None), device.pci_class_info,2691 (None, None, None), device.pci_class_info,
2669 'Invalid value of UdevDevice.pci_class_info for Non-PCI device.')2692 'Invalid value of UdevDevice.pci_class_info for Non-PCI device.')
26702693
2671 def test_pci_class(self):2694 def test_pci_class(self):
2672 """Test of UdevDevice.pci_class"""2695 """Test of UdevDevice.pci_class"""
2673 device = UdevDevice(self.pci_device_data, None, None)2696 device = UdevDevice(None, self.pci_device_data)
2674 self.assertEqual(2697 self.assertEqual(
2675 1, device.pci_class,2698 1, device.pci_class,
2676 'Invalid value of UdevDevice.pci_class for PCI device.')2699 'Invalid value of UdevDevice.pci_class for PCI device.')
26772700
2678 device = UdevDevice(self.root_device, None, None)2701 device = UdevDevice(None, self.root_device)
2679 self.assertEqual(2702 self.assertEqual(
2680 None, device.pci_class,2703 None, device.pci_class,
2681 'Invalid value of UdevDevice.pci_class for Non-PCI device.')2704 'Invalid value of UdevDevice.pci_class for Non-PCI device.')
26822705
2683 def test_pci_subclass(self):2706 def test_pci_subclass(self):
2684 """Test of UdevDevice.pci_subclass"""2707 """Test of UdevDevice.pci_subclass"""
2685 device = UdevDevice(self.pci_device_data, None, None)2708 device = UdevDevice(None, self.pci_device_data)
2686 self.assertEqual(2709 self.assertEqual(
2687 6, device.pci_subclass,2710 6, device.pci_subclass,
2688 'Invalid value of UdevDevice.pci_class for PCI device.')2711 'Invalid value of UdevDevice.pci_class for PCI device.')
26892712
2690 device = UdevDevice(self.root_device, None, None)2713 device = UdevDevice(None, self.root_device)
2691 self.assertEqual(2714 self.assertEqual(
2692 None, device.pci_class,2715 None, device.pci_class,
2693 'Invalid value of UdevDevice.pci_class for Non-PCI device.')2716 'Invalid value of UdevDevice.pci_class for Non-PCI device.')
26942717
2718 def test_pci_ids(self):
2719 """Test of UdevDevice.pci_ids"""
2720 device = UdevDevice(None, self.pci_device_data)
2721 self.assertEqual(
2722 {'vendor': 0x8086,
2723 'product': 0x27C5,
2724 },
2725 device.pci_ids,
2726 'Invalid value of UdevDevice.pci_ids for PCI device.')
2727
2728 device = UdevDevice(None, self.usb_device_data)
2729 self.assertEqual(
2730 {'vendor': None,
2731 'product': None,
2732 },
2733 device.pci_ids,
2734 'Invalid value of UdevDevice.pci_ids for Non-PCI device.')
2735
2695 def test_is_usb(self):2736 def test_is_usb(self):
2696 """Test of UdevDevice.is_usb"""2737 """Test of UdevDevice.is_usb"""
2697 device = UdevDevice(self.usb_device_data, None, None)2738 device = UdevDevice(None, self.usb_device_data)
2698 self.assertTrue(device.is_usb)2739 self.assertTrue(device.is_usb)
26992740
2700 device = UdevDevice(self.pci_device_data, None, None)2741 device = UdevDevice(None, self.pci_device_data)
2701 self.assertFalse(device.is_usb)2742 self.assertFalse(device.is_usb)
27022743
2703 def test_usb_ids(self):2744 def test_usb_ids(self):
2704 """Test of UdevDevice.usb_ids"""2745 """Test of UdevDevice.usb_ids"""
2705 device = UdevDevice(self.usb_device_data, None, None)2746 device = UdevDevice(None, self.usb_device_data)
2706 self.assertEqual(2747 self.assertEqual(
2707 [0x46d, 0xa01, 0x1013], device.usb_ids,2748 {
2749 'vendor': 0x46d,
2750 'product': 0xa01,
2751 'version': 0x1013,
2752 },
2753 device.usb_ids,
2708 'Invalid value of UdevDevice.usb_ids for USB device.')2754 'Invalid value of UdevDevice.usb_ids for USB device.')
27092755
2710 device = UdevDevice(self.root_device, None, None)2756 device = UdevDevice(None, self.root_device)
2711 self.assertEqual(2757 self.assertEqual(
2712 [None, None, None], device.usb_ids,2758 {
2759 'vendor': None,
2760 'product': None,
2761 'version': None,
2762 },
2763 device.usb_ids,
2713 'Invalid value of UdevDevice.usb_ids for Non-USB device.')2764 'Invalid value of UdevDevice.usb_ids for Non-USB device.')
27142765
2715 def test_usb_vendor_id(self):2766 def test_usb_vendor_id(self):
2716 """Test of UdevDevice.usb_vendor_id"""2767 """Test of UdevDevice.usb_vendor_id"""
2717 device = UdevDevice(self.usb_device_data, None, None)2768 device = UdevDevice(None, self.usb_device_data)
2718 self.assertEqual(2769 self.assertEqual(
2719 0x46d, device.usb_vendor_id,2770 0x46d, device.usb_vendor_id,
2720 'Invalid value of UdevDevice.usb_vendor_id for USB device.')2771 'Invalid value of UdevDevice.usb_vendor_id for USB device.')
27212772
2722 device = UdevDevice(self.root_device, None, None)2773 device = UdevDevice(None, self.root_device)
2723 self.assertEqual(2774 self.assertEqual(
2724 None, device.usb_vendor_id,2775 None, device.usb_vendor_id,
2725 'Invalid value of UdevDevice.usb_vendor_id for Non-USB device.')2776 'Invalid value of UdevDevice.usb_vendor_id for Non-USB device.')
27262777
2727 def test_usb_product_id(self):2778 def test_usb_product_id(self):
2728 """Test of UdevDevice.usb_product_id"""2779 """Test of UdevDevice.usb_product_id"""
2729 device = UdevDevice(self.usb_device_data, None, None)2780 device = UdevDevice(None, self.usb_device_data)
2730 self.assertEqual(2781 self.assertEqual(
2731 0xa01, device.usb_product_id,2782 0xa01, device.usb_product_id,
2732 'Invalid value of UdevDevice.usb_product_id for USB device.')2783 'Invalid value of UdevDevice.usb_product_id for USB device.')
27332784
2734 device = UdevDevice(self.root_device, None, None)2785 device = UdevDevice(None, self.root_device)
2735 self.assertEqual(2786 self.assertEqual(
2736 None, device.usb_product_id,2787 None, device.usb_product_id,
2737 'Invalid value of UdevDevice.usb_product_id for Non-USB device.')2788 'Invalid value of UdevDevice.usb_product_id for Non-USB device.')
@@ -2739,29 +2790,127 @@
2739 def test_is_scsi_device(self):2790 def test_is_scsi_device(self):
2740 """Test of UdevDevice.is_scsi_device."""2791 """Test of UdevDevice.is_scsi_device."""
2741 device = UdevDevice(2792 device = UdevDevice(
2742 self.scsi_device_data, self.scsi_device_sysfs_data, None)2793 None, self.scsi_device_data, self.scsi_device_sysfs_data)
2743 self.assertTrue(device.is_scsi_device)2794 self.assertTrue(device.is_scsi_device)
27442795
2745 device = UdevDevice(self.root_device, None, None)2796 device = UdevDevice(None, self.root_device)
2746 self.assertFalse(device.is_scsi_device)2797 self.assertFalse(device.is_scsi_device)
27472798
2748 def test_scsi_vendor(self):2799 def test_scsi_vendor(self):
2749 """Test of UdevDevice.scsi_vendor."""2800 """Test of UdevDevice.scsi_vendor."""
2750 device = UdevDevice(2801 device = UdevDevice(
2751 self.scsi_device_data, self.scsi_device_sysfs_data, None)2802 None, self.scsi_device_data, self.scsi_device_sysfs_data, None)
2752 self.assertEqual('MATSHITA', device.scsi_vendor)2803 self.assertEqual('MATSHITA', device.scsi_vendor)
2753 device = UdevDevice(self.root_device, None, None)2804 device = UdevDevice(None, self.root_device)
2754 self.assertEqual(None, device.scsi_vendor)2805 self.assertEqual(None, device.scsi_vendor)
27552806
2756 def test_scsi_model(self):2807 def test_scsi_model(self):
2757 """Test of UdevDevice.scsi_model."""2808 """Test of UdevDevice.scsi_model."""
2758 device = UdevDevice(2809 device = UdevDevice(
2759 self.scsi_device_data, self.scsi_device_sysfs_data, None)2810 None, self.scsi_device_data, self.scsi_device_sysfs_data)
2760 self.assertEqual('DVD-RAM UJ-841S', device.scsi_model)2811 self.assertEqual('DVD-RAM UJ-841S', device.scsi_model)
27612812
2762 device = UdevDevice(self.root_device, None, None)2813 device = UdevDevice(None, self.root_device)
2763 self.assertEqual(None, device.scsi_model)2814 self.assertEqual(None, device.scsi_model)
27642815
2816 def test_raw_bus(self):
2817 """Test of UdevDevice.raw_bus."""
2818 device = UdevDevice(None, self.root_device)
2819 self.assertEqual(None, device.raw_bus)
2820
2821 device = UdevDevice(None, self.pci_device_data)
2822 self.assertEqual('pci', device.raw_bus)
2823
2824 device = UdevDevice(None, self.usb_device_data)
2825 self.assertEqual('usb_device', device.raw_bus)
2826
2827 device = UdevDevice(None, self.no_subsystem_device_data)
2828 self.assertEqual(None, device.raw_bus)
2829
2830 def test_getVendorOrProduct(self):
2831 """Test of UdevDevice.getVendorOrProduct()."""
2832 device = UdevDevice(
2833 None, self.root_device, None, self.root_device_dmi_data)
2834 self.assertEqual(
2835 'FUJITSU SIEMENS', device.getVendorOrProduct('vendor'))
2836 self.assertEqual(
2837 'LIFEBOOK E8210', device.getVendorOrProduct('product'))
2838 self.assertRaises(
2839 AssertionError, device.getVendorOrProduct, 'nonsense')
2840
2841 device = UdevDevice(None, self.pci_device_data)
2842 self.assertEqual('Unknown', device.getVendorOrProduct('vendor'))
2843 self.assertEqual('Unknown', device.getVendorOrProduct('product'))
2844
2845 device = UdevDevice(None, self.usb_device_data)
2846 self.assertEqual('Unknown', device.getVendorOrProduct('vendor'))
2847 self.assertEqual('Unknown', device.getVendorOrProduct('product'))
2848
2849 device = UdevDevice(
2850 None, self.scsi_device_data, self.scsi_device_sysfs_data)
2851 self.assertEqual('MATSHITA', device.getVendorOrProduct('vendor'))
2852 self.assertEqual(
2853 'DVD-RAM UJ-841S', device.getVendorOrProduct('product'))
2854
2855 device = UdevDevice(None, self.no_subsystem_device_data)
2856 self.assertEqual(None, device.getVendorOrProduct('vendor'))
2857 self.assertEqual(None, device.getVendorOrProduct('product'))
2858
2859 def test_vendor(self):
2860 """Test of UdevDevice.vendor."""
2861 device = UdevDevice(
2862 None, self.root_device, None, self.root_device_dmi_data)
2863 self.assertEqual('FUJITSU SIEMENS', device.vendor)
2864
2865 def test_product(self):
2866 """Test of UdevDevice.product."""
2867 device = UdevDevice(
2868 None, self.root_device, None, self.root_device_dmi_data)
2869 self.assertEqual('LIFEBOOK E8210', device.product)
2870
2871 def test_getVendorOrProductID(self):
2872 """Test of UdevDevice.getVendorOrProduct()."""
2873 device = UdevDevice(
2874 None, self.root_device, None, self.root_device_dmi_data)
2875 self.assertEqual(
2876 'FUJITSU SIEMENS', device.getVendorOrProductID('vendor'))
2877 self.assertEqual(
2878 'LIFEBOOK E8210', device.getVendorOrProductID('product'))
2879 self.assertRaises(
2880 AssertionError, device.getVendorOrProductID, 'nonsense')
2881
2882 device = UdevDevice(None, self.pci_device_data)
2883 self.assertEqual(0x8086, device.getVendorOrProductID('vendor'))
2884 self.assertEqual(0x27C5, device.getVendorOrProductID('product'))
2885
2886 device = UdevDevice(None, self.usb_device_data)
2887 self.assertEqual(0x46d, device.getVendorOrProductID('vendor'))
2888 self.assertEqual(0xa01, device.getVendorOrProductID('product'))
2889
2890 device = UdevDevice(
2891 None, self.scsi_device_data, self.scsi_device_sysfs_data)
2892 self.assertEqual('MATSHITA', device.getVendorOrProductID('vendor'))
2893 self.assertEqual(
2894 'DVD-RAM UJ-841S', device.getVendorOrProductID('product'))
2895
2896 device = UdevDevice(
2897 None, self.no_subsystem_device_data)
2898 self.assertEqual(None, device.getVendorOrProductID('vendor'))
2899 self.assertEqual(None, device.getVendorOrProductID('product'))
2900
2901 def test_vendor_id(self):
2902 """Test of UdevDevice.vendor_id."""
2903 device = UdevDevice(
2904 None, self.root_device, None, self.root_device_dmi_data)
2905 self.assertEqual('FUJITSU SIEMENS', device.vendor_id)
2906
2907 def test_product_id(self):
2908 """Test of UdevDevice.product_id."""
2909 device = UdevDevice(
2910 None, self.root_device, None, self.root_device_dmi_data)
2911 self.assertEqual('LIFEBOOK E8210', device.product_id)
2912
2913
2765class TestHWDBSubmissionTablePopulation(TestCaseHWDB):2914class TestHWDBSubmissionTablePopulation(TestCaseHWDB):
2766 """Tests of the HWDB popoluation with submitted data."""2915 """Tests of the HWDB popoluation with submitted data."""
27672916

Subscribers

People subscribed via source and target branches

to status/vote changes: