def test_from_device_file_no_device_file(self, tmpdir, a_context): filename = tmpdir.join('test') filename.ensure(file=True) with pytest.raises(DeviceNotFoundByFileError) as excinfo: Devices.from_device_file(a_context, str(filename)) message = 'not a device file: {0!r}'.format(str(filename)) assert str(excinfo.value) == message
def test_from_path_strips_leading_slash(self, a_context, a_device): """ from_path() yields the same value, even if initial '/' is missing. """ path = a_device.device_path assert Devices.from_path(a_context, path[1:]) == \ Devices.from_path(a_context, path)
def test_from_sys_path_device_not_found(self, a_context): sys_path = 'there_will_not_be_such_a_device' with pytest.raises(DeviceNotFoundAtPathError) as exc_info: Devices.from_sys_path(a_context, sys_path) error = exc_info.value assert error.sys_path == sys_path assert str(error) == 'No device at {0!r}'.format(sys_path)
def test_from_name_is_path(self, a_context, a_device): """ Lookup using a sys_name which is actually a path should always fail. See: rhbz#1263351. """ with pytest.raises(DeviceNotFoundByNameError): Devices.from_name(a_context, a_device.subsystem, a_device.sys_name)
def test_from_name_nonexisting_subsystem(self, a_context): with pytest.raises(DeviceNotFoundByNameError) as exc_info: Devices.from_name(a_context, 'no_such_subsystem', 'foobar') error = exc_info.value assert error.subsystem == 'no_such_subsystem' assert error.sys_name == 'foobar' assert str(error) == 'No device {0!r} in {1!r}'.format( error.sys_name, error.subsystem)
def test_from_device_file_non_existing(self, tmpdir, a_context): """ Test that an OSError is raised when constructing a ``Device`` from a file that does not actually exist. """ filename = tmpdir.join('test_from_device_file_non_existing') assert not tmpdir.check(file=True) with pytest.raises(DeviceNotFoundByFileError): Devices.from_device_file(a_context, str(filename))
def test_from_sys_path_device_not_found(self): """ Verify that a non-existant sys_path causes an exception. """ sys_path = 'there_will_not_be_such_a_device' with pytest.raises(DeviceNotFoundAtPathError) as exc_info: Devices.from_sys_path(_CONTEXT, sys_path) error = exc_info.value assert error.sys_path == sys_path
def test_from_name_nonexisting_subsystem(self): """ Verify that a non-existant subsystem causes an exception. """ with pytest.raises(DeviceNotFoundByNameError) as exc_info: Devices.from_name(_CONTEXT, 'no_such_subsystem', 'foobar') error = exc_info.value assert error.subsystem == 'no_such_subsystem' assert error.sys_name == 'foobar'
def _check_device(device): """ Check that device exists by getting it. """ try: Devices.from_path(_CONTEXT, device.sys_path) return True except DeviceNotFoundError: return False
def test_from_device_file_non_existing(self, tmpdir): """ Test that an OSError is raised when constructing a ``Device`` from a file that does not actually exist. """ filename = tmpdir.join('test_from_device_file_non_existing') assert not tmpdir.check(file=True) with pytest.raises(DeviceNotFoundByFileError): Devices.from_device_file(_CONTEXT, str(filename))
def test_from_device_file_no_device_file(self, tmpdir): """ Verify that a file that is not a device file will cause an exception to be raised. """ filename = tmpdir.join('test') filename.ensure(file=True) with pytest.raises(DeviceNotFoundByFileError): Devices.from_device_file(_CONTEXT, str(filename))
def test_from_name_no_device_in_existing_subsystem(self, a_context, subsys): """ Verify that a real subsystem and non-existant name causes an exception to be raised. """ with pytest.raises(DeviceNotFoundByNameError) as exc_info: Devices.from_name(a_context, subsys, 'foobar') error = exc_info.value assert error.subsystem == subsys assert error.sys_name == 'foobar'
def test_from_kernel_device(self, a_context, entry): """ Test that kernel devices can be obtained. """ kernel_device = entry['_KERNEL_DEVICE'] device = Devices.from_kernel_device(a_context, kernel_device) assert device is not None
def test_getitem(self, a_context, device_datum): """ Test that attribute value exists and is instance of bytes. """ device = Devices.from_path(a_context, device_datum.device_path) assert all(isinstance(device.attributes.get(key), bytes) \ for key in device_datum.attributes.keys())
def test_from_device_file(self, a_context, device_datum): device = Devices.from_device_file( a_context, device_datum.device_node ) assert device.device_node == device_datum.device_node assert device.device_path == device_datum.device_path
def test_key_subset(self, a_context, device_datum): """ Verify that the device contains all the keys in the device datum. """ device = Devices.from_path(a_context, device_datum.device_path) assert frozenset(device_datum.properties.keys()) <= \ frozenset(device.properties.keys())
def test_asstring(self, a_context, device_datum): """ Test that attribute exists for actual device and is unicode. """ device = Devices.from_path(a_context, device_datum.device_path) assert all(is_unicode_string(device.attributes.asstring(key)) \ for key in device_datum.attributes.keys())
def test_iteration_and_contains(self, a_context, device_datum): """ Test that iteration yields all tags and contains checks them. """ device = Devices.from_path(a_context, device_datum.device_path) assert frozenset(device.tags) == frozenset(device_datum.tags) assert all(is_unicode_string(tag) for tag in device.tags)
def test_events_real(self, context, monitor): # make sure that the module is unloaded initially pytest.unload_dummy() monitor.filter_by('net') monitor.start() self.prepare_test(monitor) # setup signal handlers event_callback = mock.Mock(side_effect=self.stop_when_done) added_callback = mock.Mock(side_effect=self.stop_when_done) removed_callback = mock.Mock(side_effect=self.stop_when_done) self.connect_signal(event_callback) self.connect_signal(added_callback, action='add') self.connect_signal(removed_callback, action='remove') # test add event self.start_event_loop(pytest.load_dummy) device = Devices.from_path(context, '/devices/virtual/net/dummy0') event_callback.assert_called_with('add', device) added_callback.assert_called_with(device) assert not removed_callback.called for callback in (event_callback, added_callback, removed_callback): callback.reset_mock() self.start_event_loop(pytest.unload_dummy) event_callback.assert_called_with('remove', device) assert not added_callback.called removed_callback.assert_called_with(device)
def map_nvme(self, info, acpihandles): mapped = info[-1] num_of_nvme_slots = info[-2] ctx = Context() for i in filter(lambda x: x.attributes.get('path') in acpihandles, ctx.list_devices(subsystem='acpi')): acpi_handle = i.attributes.get('path') try: phys_node = Devices.from_path(ctx, f'{i.sys_path}/physical_node') except DeviceNotFoundAtPathError: return info slot = acpihandles[acpi_handle] for nvme in filter(lambda x: x.sys_name.startswith('nvme'), phys_node.children): mapped[slot] = nvme.sys_name break else: mapped[slot] = None if len(mapped) == num_of_nvme_slots: return info return info
def test_getitem_devname(self, a_context, device_datum): device = Devices.from_path(a_context, device_datum.device_path) data_devname = os.path.join( a_context.device_path, device_datum.properties['DEVNAME']) device_devname = \ os.path.join(a_context.device_path, device.properties['DEVNAME']) assert device_devname == data_devname
def findGoodWeUSBDevice(self, vendorId, modelId): context = Context() # directory = "/dev/bus/usb/001/" directory = "/dev/" usb_list = [d for d in os.listdir("/dev") if d.startswith("hidraw")] # usb_list = [d for d in os.listdir(directory)] self.log.debug(usb_list) for hidraw in usb_list: # device = directory + hidraw device = "/dev/" + hidraw try: udev = Devices.from_device_file(context, device) self.log.debug(udev['DEVPATH']) if udev['DEVPATH'].find(vendorId + ":" + modelId) > -1: self.log.debug("Using: %s", hidraw) return device except Exception as e: self.log.debug(e) pass return None
def test_length(self, a_context, device_datum): """ Verify that the keys in the device and in the datum are equal. """ device = Devices.from_path(a_context, device_datum.device_path) assert frozenset(device_datum.properties.keys()) == \ frozenset(device.properties.keys())
def test_from_device_number(self, a_context, device_datum): mode = os.stat(device_datum.device_node).st_mode typ = 'block' if stat.S_ISBLK(mode) else 'char' device = Devices.from_device_number( a_context, typ, device_datum.device_number) assert device.device_number == device_datum.device_number # make sure, we are really referring to the same device assert device.device_path == device_datum.device_path
def test_iteration(self, a_context, device_datum): device = Devices.from_path(a_context, device_datum.device_path) for property in device: assert is_unicode_string(property) # test that iteration really yields all properties device_properties = set(device) for property in device_datum.properties: assert property in device_properties
def __isCDInserted(self) -> bool: # using another udev context - running in a different thread try: context = pyudev.Context() device = Devices.from_device_file(context, DEV_CDROM) return MEDIA_TRACK_COUNT_AUDIO_UDEV_TAG in device except Exception: return False
def test_from_name(self, a_context, a_device): """ Test that getting a new device based on the name and subsystem yields an equivalent device. """ new_device = Devices.from_name(a_context, a_device.subsystem, a_device.sys_name) assert new_device == a_device
def test_from_journal_name(self, a_context, entry): """ Test that kernel subsystem combined with udev sysname yields a device. """ udev_sysname = entry['_UDEV_SYSNAME'] subsystem = entry['_KERNEL_SUBSYSTEM'] device = Devices.from_name(a_context, subsystem, udev_sysname) assert device is not None
def test_from_device_number(self, a_context, a_device): """ Verify that from_device_number() yields the correct device. """ mode = os.stat(a_device.device_node).st_mode typ = 'block' if stat.S_ISBLK(mode) else 'char' device = \ Devices.from_device_number(a_context, typ, a_device.device_number) assert a_device == device
def test_asint(self, a_context, device_datum): device = Devices.from_path(a_context, device_datum.device_path) for property, value in device_datum.properties.items(): try: value = int(value) except ValueError: with pytest.raises(ValueError): device.asint(property) else: assert device.asint(property) == value
def test_asbool(self, a_context, device_datum): """ Test that bool result is a bool or ValueError raised. """ device = Devices.from_path(a_context, device_datum.device_path) for key, value in device_datum.attributes.items(): if value in ('0', '1'): assert device.attributes.asbool(key) in (False, True) else: with pytest.raises(ValueError): device.attributes.asbool(key)
def test_asint(self, a_context, device_datum): """ Test that integer result is an int or ValueError raised. """ device = Devices.from_path(a_context, device_datum.device_path) for key, value in device_datum.attributes.items(): try: value = int(value) except ValueError: with pytest.raises(ValueError): device.attributes.asint(key)
def test_getitem(self, a_context, device_datum): device = Devices.from_path(a_context, device_datum.device_path) for prop in device_datum.properties: if prop == 'DEVLINKS': assert sorted(device.properties[prop].split(),) == \ sorted(device_datum.properties[prop].split(),) elif prop == 'TAGS': assert sorted(device.properties[prop].split(':'),) == \ sorted(device_datum.properties[prop].split(':'),) else: assert device.properties[prop] == device_datum.properties[prop]
def test_from_device_file_links(self, a_context, device_datum): """ For each link in DEVLINKS, test that the constructed device's path matches the orginal devices path. This does not hold true in the case of multipath. In this case udevadm's DEVLINKS fields holds some links that do not actually point to the originating device. See: https://bugzilla.redhat.com/show_bug.cgi?id=1263441. """ device = Devices.from_path(a_context, device_datum.device_path) assume(not 'DM_MULTIPATH_TIMESTAMP' in device) for link in device_datum.device_links: link = os.path.join(a_context.device_path, link) device = Devices.from_device_file(a_context, link) assert device.device_path == device_datum.device_path assert link in device.device_links
def test_from_name(self, a_context, a_device): """ Test that getting a new device based on the name and subsystem yields an equivalent device. """ new_device = Devices.from_name( a_context, a_device.subsystem, a_device.sys_name ) assert new_device == a_device
def test_asbool(self, a_context, device_datum): device = Devices.from_path(a_context, device_datum.device_path) for prop, value in device_datum.properties.items(): if value == '1': assert device.asbool(prop) elif value == '0': assert not device.asbool(prop) else: with pytest.raises(ValueError) as exc_info: device.asbool(prop) message = 'Not a boolean value: {0!r}' assert str(exc_info.value) == message.format(value)
def test_asbool(self, a_context, device_datum): """ Test that values of 1 and 0 get properly interpreted as bool and that all other values raise a ValueError. :param Context a_context: libudev context :param device_datum: a device datum """ device = Devices.from_path(a_context, device_datum.device_path) for prop, value in device_datum.properties.items(): if value == '1': assert device.properties.asbool(prop) elif value == '0': assert not device.properties.asbool(prop) else: with pytest.raises(ValueError) as exc_info: device.properties.asbool(prop)
def test_events_real(self, context, monitor): # make sure that the module is unloaded initially pytest.unload_dummy() monitor.filter_by('net') monitor.start() self.prepare_test(monitor) # setup signal handlers event_callback = mock.Mock( side_effect=lambda *args: self.stop_event_loop()) self.connect_signal(event_callback) # test add event self.start_event_loop(pytest.load_dummy) device = Devices.from_path(context, '/devices/virtual/net/dummy0') event_callback.assert_called_with(device) event_callback.reset_mock() self.start_event_loop(pytest.unload_dummy) event_callback.assert_called_with(device)
def test_from_device_number_wrong_type( self, a_context, device_datum ): mode = os.stat(device_datum.device_node).st_mode # deliberately use the wrong type here to cause either failure # or at least device mismatch typ = 'char' if stat.S_ISBLK(mode) else 'block' try: # this either fails, in which case the caught exception is # raised, or succeeds, but returns a wrong device # (device numbers are not unique across device types) device = Devices.from_device_number( a_context, typ, device_datum.device_number) # if it succeeds, the resulting device must not match the # one, we are actually looking for! assert device.device_path != device_datum.device_path except DeviceNotFoundByNumberError as error: # check the correctness of the exception attributes assert error.device_type == typ assert error.device_number == device_datum.device_number
def test_getitem(self, a_context, device_datum): device = Devices.from_path(a_context, device_datum.device_path) for prop in device_datum.properties: assert device[prop] == device_datum.properties[prop]
def test_length(self, a_context, device_datum): device = Devices.from_path(a_context, device_datum.device_path) assert len(device) == len(device_datum.properties)