def setUp(self):
super(TestBaseIronicPythonAgent, self).setUp()
self.api_client = ironic_api_client.APIClient(API_URL)
self.hardware_info = {
'interfaces': [
hardware.NetworkInterface('eth0',
'00:0c:29:8c:11:b1',
vendor='0x15b3',
product='0x1014'),
hardware.NetworkInterface('eth1',
'00:0c:29:8c:11:b2',
lldp=[
(1, '04885a92ec5459'),
(2, '0545746865726e6574312f3138')
],
vendor='0x15b3',
product='0x1014'),
],
'cpu':
hardware.CPU('Awesome Jay CPU x10 9001', '9001', '10', 'ARMv9'),
'disks': [
hardware.BlockDevice('/dev/sdj', 'small', '9001', False),
hardware.BlockDevice('/dev/hdj', 'big', '9002', False),
],
'memory':
hardware.Memory(total='8675309', physical_mb='8675'),
}
def test_get_os_install_device_root_device_hints(self, mock_root_device,
mock_dev):
model = 'fastable sd131 7'
mock_root_device.return_value = {
'model': model,
'wwn': 'fake-wwn',
'serial': 'fake-serial',
'vendor': 'fake-vendor',
'size': 10
}
mock_dev.return_value = [
hardware.BlockDevice(name='/dev/sda',
model='TinyUSB Drive',
size=3116853504,
rotational=False,
vendor='Super Vendor',
wwn='wwn0',
serial='serial0'),
hardware.BlockDevice(name='/dev/sdb',
model=model,
size=10737418240,
rotational=False,
vendor='fake-vendor',
wwn='fake-wwn',
serial='fake-serial'),
]
self.assertEqual('/dev/sdb', self.hardware.get_os_install_device())
mock_root_device.assert_called_once_with()
mock_dev.assert_called_once_with()
def _get_os_install_device_root_device_hints(self, hints, expected_device,
mock_root_device, mock_dev):
model = 'fastable sd131 7'
mock_root_device.return_value = hints
mock_dev.return_value = [
hardware.BlockDevice(name='/dev/sda',
model='TinyUSB Drive',
size=3116853504,
rotational=False,
vendor='Super Vendor',
wwn='wwn0',
wwn_with_extension='wwn0ven0',
wwn_vendor_extension='ven0',
serial='serial0'),
hardware.BlockDevice(name='/dev/sdb',
model=model,
size=10737418240,
rotational=False,
vendor='fake-vendor',
wwn='fake-wwn',
wwn_with_extension='fake-wwnven0',
wwn_vendor_extension='ven0',
serial='fake-serial'),
]
self.assertEqual(expected_device,
self.hardware.get_os_install_device())
mock_root_device.assert_called_once_with()
mock_dev.assert_called_once_with()
def test_get_os_install_device_root_device_hints_no_device_found(
self, mock_root_device, mock_dev):
model = 'fastable sd131 7'
mock_root_device.return_value = {
'model': model,
'wwn': 'fake-wwn',
'serial': 'fake-serial',
'vendor': 'fake-vendor',
'size': 10
}
# Model is different here
mock_dev.return_value = [
hardware.BlockDevice(name='/dev/sda',
model='TinyUSB Drive',
size=3116853504,
rotational=False,
vendor='Super Vendor',
wwn='wwn0',
serial='serial0'),
hardware.BlockDevice(name='/dev/sdb',
model='Another Model',
size=10737418240,
rotational=False,
vendor='fake-vendor',
wwn='fake-wwn',
serial='fake-serial'),
]
self.assertRaises(errors.DeviceNotFound,
self.hardware.get_os_install_device)
mock_root_device.assert_called_once_with()
mock_dev.assert_called_once_with()
def test_list_hardware_info(self):
self.hardware.list_network_interfaces = mock.Mock()
self.hardware.list_network_interfaces.return_value = [
hardware.NetworkInterface('eth0', '00:0c:29:8c:11:b1'),
hardware.NetworkInterface('eth1', '00:0c:29:8c:11:b2'),
]
self.hardware.get_cpus = mock.Mock()
self.hardware.get_cpus.return_value = hardware.CPU(
'Awesome CPU x14 9001', 9001, 14)
self.hardware.get_memory = mock.Mock()
self.hardware.get_memory.return_value = hardware.Memory(1017012)
self.hardware.list_block_devices = mock.Mock()
self.hardware.list_block_devices.return_value = [
hardware.BlockDevice('/dev/sdj', 'big', 1073741824, True),
hardware.BlockDevice('/dev/hdaa', 'small', 65535, False),
]
hardware_info = self.hardware.list_hardware_info()
self.assertEqual(hardware_info['memory'], self.hardware.get_memory())
self.assertEqual(hardware_info['cpu'], self.hardware.get_cpus())
self.assertEqual(hardware_info['disks'],
self.hardware.list_block_devices())
self.assertEqual(hardware_info['interfaces'],
self.hardware.list_network_interfaces())
def test_guess_root_disk_to_big(self):
devices = [
hardware.BlockDevice(name='/dev/sdd',
model='NWD-BLP4-1600',
size=207374182400,
rotational=False,
vendor='Super Vendor',
hctl='1:0:0:0'),
hardware.BlockDevice(name='/dev/sda',
model='TinyUSB Drive',
size=3116853504,
rotational=False,
vendor='Super Vendor',
hctl='1:0:0:0'),
hardware.BlockDevice(name='/dev/sdc',
model='NWD-BLP4-1600',
size=107374182400,
rotational=False,
vendor='Super Vendor',
hctl='1:0:0:0'),
hardware.BlockDevice(name='/dev/sdb',
model='Fastable SD131 7',
size=107374182400,
rotational=False,
vendor='Super Vendor',
hctl='1:0:0:0'),
]
self.assertRaises(errors.DeviceNotFound, utils.guess_root_disk,
devices, 200 * units.Gi)
def _test_guess_root_disk(self, size=8, device_name='/dev/vda'):
devices = [
hardware.BlockDevice(name='/dev/sdd',
model='NWD-BLP4-1600',
size=207374182400,
rotational=False,
vendor='Super Vendor',
hctl='1:0:0:0'),
hardware.BlockDevice(name='/dev/sda',
model='TinyUSB Drive',
size=3116853504,
rotational=False,
vendor='Super Vendor',
hctl='1:0:0:0'),
hardware.BlockDevice(name='/dev/sdc',
model='NWD-BLP4-1600',
size=107374182400,
rotational=False,
vendor='Super Vendor',
hctl='1:0:0:0'),
hardware.BlockDevice(name='/dev/sdb',
model='Fastable SD131 7',
size=107374182400,
rotational=False,
vendor='Super Vendor',
hctl='1:0:0:0'),
]
require_device_name = device_name
device = utils.guess_root_disk(devices, size * units.Gi)
self.assertEqual(device.name, require_device_name)
def test_list_block_device(self, mocked_execute):
mocked_execute.return_value = (BLK_DEVICE_TEMPLATE, '')
devices = self.hardware.list_block_devices()
expected_devices = [
hardware.BlockDevice(name='/dev/sda',
model='TinyUSB Drive',
size=3116853504,
rotational=False),
hardware.BlockDevice(name='/dev/sdb',
model='Fastable SD131 7',
size=31016853504,
rotational=False),
hardware.BlockDevice(name='/dev/sdc',
model='NWD-BLP4-1600',
size=1765517033472,
rotational=False),
hardware.BlockDevice(name='/dev/sdd',
model='NWD-BLP4-1600',
size=1765517033472,
rotational=False)
]
self.assertEqual(4, len(expected_devices))
for expected, device in zip(expected_devices, devices):
# Compare all attrs of the objects
for attr in ['name', 'model', 'size', 'rotational']:
self.assertEqual(getattr(expected, attr),
getattr(device, attr))
def setUp(self):
super(BaseDiscoverTest, self).setUp()
self.inventory = {
'interfaces': [
hardware.NetworkInterface(name='em1',
mac_addr='aa:bb:cc:dd:ee:ff',
ipv4_address='1.1.1.1'),
hardware.NetworkInterface(name='em2',
mac_addr='11:22:33:44:55:66',
ipv4_address=None),
],
'cpu': hardware.CPU(model_name='generic', frequency='3000',
count=4, architecture='x86_64'),
'memory': hardware.Memory(total=11998396 * 1024,
physical_mb=12288),
'disks': [
hardware.BlockDevice(name='/dev/sdc',
model='Disk 2',
size=500107862016,
rotational=False),
hardware.BlockDevice(name='/dev/sda',
model='Too Small Disk',
size=4294967295,
rotational=False),
hardware.BlockDevice(name='/dev/sdb',
model='Disk 1',
size=500107862016,
rotational=True)
],
'bmc_address': '1.2.3.4',
'boot': hardware.BootInfo(current_boot_mode='bios',
pxe_interface='boot:if')
}
self.failures = utils.AccumulatedFailures()
self.data = {}
def test_list_all_block_device_with_udev(self, mocked_execute, mocked_udev,
mocked_dev_vendor):
mocked_execute.return_value = (BLK_DEVICE_TEMPLATE, '')
mocked_udev.side_effect = iter([
{'ID_WWN': 'wwn%d' % i, 'ID_SERIAL_SHORT': 'serial%d' % i,
'ID_WWN_WITH_EXTENSION': 'wwn-ext%d' % i,
'ID_WWN_VENDOR_EXTENSION': 'wwn-vendor-ext%d' % i}
for i in range(4)
])
mocked_dev_vendor.return_value = 'Super Vendor'
devices = hardware.list_all_block_devices()
expected_devices = [
hardware.BlockDevice(name='/dev/sda',
model='TinyUSB Drive',
size=3116853504,
rotational=False,
vendor='Super Vendor',
wwn='wwn0',
wwn_with_extension='wwn-ext0',
wwn_vendor_extension='wwn-vendor-ext0',
serial='serial0'),
hardware.BlockDevice(name='/dev/sdb',
model='Fastable SD131 7',
size=10737418240,
rotational=False,
vendor='Super Vendor',
wwn='wwn1',
wwn_with_extension='wwn-ext1',
wwn_vendor_extension='wwn-vendor-ext1',
serial='serial1'),
hardware.BlockDevice(name='/dev/sdc',
model='NWD-BLP4-1600',
size=1765517033472,
rotational=False,
vendor='Super Vendor',
wwn='wwn2',
wwn_with_extension='wwn-ext2',
wwn_vendor_extension='wwn-vendor-ext2',
serial='serial2'),
hardware.BlockDevice(name='/dev/sdd',
model='NWD-BLP4-1600',
size=1765517033472,
rotational=False,
vendor='Super Vendor',
wwn='wwn3',
wwn_with_extension='wwn-ext3',
wwn_vendor_extension='wwn-vendor-ext3',
serial='serial3')
]
self.assertEqual(4, len(expected_devices))
for expected, device in zip(expected_devices, devices):
# Compare all attrs of the objects
for attr in ['name', 'model', 'size', 'rotational',
'wwn', 'vendor', 'serial', 'wwn_with_extension',
'wwn_vendor_extension']:
self.assertEqual(getattr(expected, attr),
getattr(device, attr))
def test_list_hardware_info(self):
self.hardware.list_network_interfaces = mock.Mock()
self.hardware.list_network_interfaces.return_value = [
hardware.NetworkInterface('eth0', '00:0c:29:8c:11:b1'),
hardware.NetworkInterface('eth1', '00:0c:29:8c:11:b2'),
]
self.hardware.get_cpus = mock.Mock()
self.hardware.get_cpus.return_value = hardware.CPU(
'Awesome CPU x14 9001',
9001,
14,
'x86_64')
self.hardware.get_memory = mock.Mock()
self.hardware.get_memory.return_value = hardware.Memory(1017012)
self.hardware.list_block_devices = mock.Mock()
self.hardware.list_block_devices.return_value = [
hardware.BlockDevice('/dev/sdj', 'big', 1073741824, True),
hardware.BlockDevice('/dev/hdaa', 'small', 65535, False),
]
self.hardware.list_physical_devices = mock.Mock()
self.hardware.list_physical_devices.return_value = [
arcconf.PhysicalDisk(ID='0 0',
ControllerID='1',
Type='SAS',
Size='558.91 GB'),
arcconf.PhysicalDisk(ID='0 1',
ControllerID='1',
Type='SAS',
Size='558.91 GB'),
]
self.hardware.get_boot_info = mock.Mock()
self.hardware.get_boot_info.return_value = hardware.BootInfo(
current_boot_mode='bios', pxe_interface='boot:if')
self.hardware.get_bmc_address = mock.Mock()
self.hardware.get_system_vendor_info = mock.Mock()
hardware_info = self.hardware.list_hardware_info()
self.assertEqual(self.hardware.get_memory(),
hardware_info['memory'])
self.assertEqual(self.hardware.get_cpus(), hardware_info['cpu'])
self.assertEqual(self.hardware.list_block_devices(),
hardware_info['disks'])
self.assertEqual(self.hardware.list_physical_devices(),
hardware_info['physical_disks'])
self.assertEqual(self.hardware.list_network_interfaces(),
hardware_info['interfaces'])
self.assertEqual(self.hardware.get_boot_info(),
hardware_info['boot'])
def test_verify_blockdevice_count_io_missing_satadom(self):
self.hardware._get_flavor_from_node = mock.Mock()
self.hardware._get_flavor_from_node.return_value = 'onmetal-io1'
self.hardware.list_block_devices = mock.Mock()
self.hardware.list_block_devices.return_value = [
hardware.BlockDevice('/dev/sda', 'NWD-BLP4-1600', 1073741824,
False),
hardware.BlockDevice('/dev/sdb', 'NWD-BLP4-1600', 1073741824,
False)]
self.assertRaises(errors.CleaningError,
self.hardware.verify_hardware, {}, [])
def test_verify_blockdevice_count_io_pass(self):
self.hardware._get_flavor_from_node = mock.Mock()
self.hardware._get_flavor_from_node.return_value = 'onmetal-io1'
self.hardware.list_block_devices = mock.Mock()
self.hardware.list_block_devices.return_value = [
hardware.BlockDevice('/dev/sda', 'NWD-BLP4-1600', 1073741824,
False),
hardware.BlockDevice('/dev/sdb', 'NWD-BLP4-1600', 1073741824,
False),
hardware.BlockDevice('/dev/sdc', '32G MLC SATADOM', 33554432,
False)]
self.hardware.verify_hardware({}, [])
def test_guess_root_disk_disks_too_small(self, mock_call):
block_devices = [
hardware.BlockDevice(name='/dev/sda',
model='too small',
size=4294967295,
rotational=True),
hardware.BlockDevice(name='/dev/sdb',
model='way too small',
size=1,
rotational=True),
]
self.assertRaises(errors.DeviceNotFound, utils.guess_root_disk,
block_devices)
def test_erase_devices(self, mocked_dispatch):
mocked_dispatch.return_value = 'erased device'
self.hardware.list_block_devices = mock.Mock()
self.hardware.list_block_devices.return_value = [
hardware.BlockDevice('/dev/sdj', 'big', 1073741824, True),
hardware.BlockDevice('/dev/hdaa', 'small', 65535, False),
]
expected = {'/dev/hdaa': 'erased device', '/dev/sdj': 'erased device'}
result = self.hardware.erase_devices({}, [])
self.assertEqual(expected, result)
def test_erase_block_device_ata_security_enabled_unlock_attempt(
self, mocked_execute, mock_shred):
hdparm_output = HDPARM_INFO_TEMPLATE % {
'supported': '\tsupported',
'enabled': '\tenabled',
'frozen': 'not\tfrozen',
'enhanced_erase': 'not\tsupported: enhanced erase',
}
hdparm_output_not_enabled = HDPARM_INFO_TEMPLATE % {
'supported': '\tsupported',
'enabled': 'not\tenabled',
'frozen': 'not\tfrozen',
'enhanced_erase': 'not\tsupported: enhanced erase',
}
mocked_execute.side_effect = [(hdparm_output, ''), '',
(hdparm_output_not_enabled, ''), '', '',
(hdparm_output_not_enabled, '')]
block_device = hardware.BlockDevice('/dev/sda', 'big', 1073741824,
True)
self.hardware.erase_block_device(self.node, block_device)
self.assertFalse(mock_shred.called)
def test_erase_block_device_ata_failed_continued(self, mocked_execute,
mock_shred):
info = self.node.get('driver_internal_info')
info['agent_continue_if_ata_erase_failed'] = True
hdparm_output_before = HDPARM_INFO_TEMPLATE % {
'supported': '\tsupported',
'enabled': 'not\tenabled',
'frozen': 'not\tfrozen',
'enhanced_erase': 'not\tsupported: enhanced erase',
}
# If security mode remains enabled after the erase, it is indiciative
# of a failed erase.
hdparm_output_after = HDPARM_INFO_TEMPLATE % {
'supported': '\tsupported',
'enabled': '\tenabled',
'frozen': 'not\tfrozen',
'enhanced_erase': 'not\tsupported: enhanced erase',
}
mocked_execute.side_effect = [
(hdparm_output_before, ''),
('', ''),
('', ''),
(hdparm_output_after, ''),
]
block_device = hardware.BlockDevice('/dev/sda', 'big', 1073741824,
True)
self.hardware.erase_block_device(self.node, block_device)
self.assertTrue(mock_shred.called)
def test_erase_block_device_ata_success(self, mocked_execute):
hdparm_info_fields = {
'supported': '\tsupported',
'enabled': 'not\tenabled',
'frozen': 'not\tfrozen',
'enhanced_erase': 'not\tsupported: enhanced erase',
}
mocked_execute.side_effect = [
(HDPARM_INFO_TEMPLATE % hdparm_info_fields, ''),
('', ''),
('', ''),
(HDPARM_INFO_TEMPLATE % hdparm_info_fields, ''),
]
block_device = hardware.BlockDevice('/dev/sda', 'big', 1073741824,
True)
self.hardware.erase_block_device(self.node, block_device)
mocked_execute.assert_has_calls([
mock.call('hdparm', '-I', '/dev/sda'),
mock.call('hdparm', '--user-master', 'u', '--security-set-pass',
'NULL', '/dev/sda'),
mock.call('hdparm', '--user-master', 'u', '--security-erase',
'NULL', '/dev/sda'),
mock.call('hdparm', '-I', '/dev/sda'),
])
def test_erase_block_device_ata_failed(self, mocked_execute):
hdparm_output_before = HDPARM_INFO_TEMPLATE % {
'supported': '\tsupported',
'enabled': 'not\tenabled',
'frozen': 'not\tfrozen',
}
# If security mode remains enabled after the erase, it is indiciative
# of a failed erase.
hdparm_output_after = HDPARM_INFO_TEMPLATE % {
'supported': '\tsupported',
'enabled': '\tenabled',
'frozen': 'not\tfrozen',
}
mocked_execute.side_effect = [
(hdparm_output_before, ''),
('', ''),
('', ''),
(hdparm_output_after, ''),
]
block_device = hardware.BlockDevice('/dev/sda', 'big', 1073741824,
True)
self.assertRaises(errors.BlockDeviceEraseError,
self.hardware.erase_block_device, block_device)
def test__ata_erase_security_enabled_set_password_exception(
self, mocked_execute):
hdparm_output = HDPARM_INFO_TEMPLATE % {
'supported': '\tsupported',
'enabled': '\tenabled',
'frozen': 'not\tfrozen',
'enhanced_erase': 'not\tsupported: enhanced erase',
}
hdparm_output_not_enabled = HDPARM_INFO_TEMPLATE % {
'supported': '\tsupported',
'enabled': 'not\tenabled',
'frozen': 'not\tfrozen',
'enhanced_erase': 'not\tsupported: enhanced erase',
}
mocked_execute.side_effect = [(hdparm_output, ''), '',
(hdparm_output_not_enabled, ''), '',
processutils.ProcessExecutionError()]
block_device = hardware.BlockDevice('/dev/sda', 'big', 1073741824,
True)
self.assertRaises(errors.BlockDeviceEraseError,
self.hardware._ata_erase, block_device)
def test_erase_block_device_shred_fail_processerror(self, mocked_execute):
mocked_execute.side_effect = processutils.ProcessExecutionError
block_device = hardware.BlockDevice('/dev/sda', 'big', 1073741824,
True)
res = self.hardware._shred_block_device(self.node, block_device)
self.assertFalse(res)
mocked_execute.assert_called_once_with('shred', '--force', '--zero',
'--verbose', '--iterations', '1', '/dev/sda')
def setUp(self):
super(TestBaseIronicPythonAgent, self).setUp()
self.api_client = ironic_api_client.APIClient(API_URL, DRIVER)
self.hardware_info = {
'interfaces': [
hardware.NetworkInterface('eth0', '00:0c:29:8c:11:b1'),
hardware.NetworkInterface('eth1', '00:0c:29:8c:11:b2'),
],
'cpu': hardware.CPU('Awesome Jay CPU x10 9001', '9001', '10',
'ARMv9'),
'disks': [
hardware.BlockDevice('/dev/sdj', 'small', '9001', False),
hardware.BlockDevice('/dev/hdj', 'big', '9002', False),
],
'memory': hardware.Memory(total='8675309',
physical_mb='8675'),
}
def test_list_block_devices(self, list_mock):
device = hardware.BlockDevice('/dev/hdaa', 'small', 65535, False)
list_mock.return_value = [device]
devices = self.hardware.list_block_devices()
self.assertEqual([device], devices)
list_mock.assert_called_once_with()
def test_verify_blockdevice_count_pass(self):
self.hardware._get_flavor_from_node = mock.Mock()
self.hardware._get_flavor_from_node.return_value = 'onmetal-compute1'
self.hardware.list_block_devices = mock.Mock()
self.hardware.list_block_devices.return_value = [
hardware.BlockDevice('/dev/sda', '32G MLC SATADOM', 33554432,
False)]
self.hardware.verify_hardware({}, [])
def test_fio_disk_default(self, mock_list, mock_execute):
node = {'driver_info': {}}
mock_list.return_value = [
hardware.BlockDevice('/dev/sdj', 'big', 1073741824, True),
hardware.BlockDevice('/dev/hdaa', 'small', 65535, False),
]
mock_execute.return_value = (['out', 'err'])
burnin.fio_disk(node)
mock_execute.assert_called_once_with(
'fio', '--rw', 'readwrite', '--bs', '4k', '--direct', 1,
'--ioengine', 'libaio', '--iodepth', '32', '--verify', 'crc32c',
'--verify_dump', 1, '--continue_on_error', 'verify', '--loops', 4,
'--runtime', 0, '--time_based', '--name', '/dev/sdj', '--name',
'/dev/hdaa')
def test_erase_block_device_ata_nosecurity(self, mocked_execute):
hdparm_output = HDPARM_INFO_TEMPLATE.split('\nSecurity:')[0]
mocked_execute.side_effect = [(hdparm_output, '')]
block_device = hardware.BlockDevice('/dev/sda', 'big', 1073741824,
True)
self.assertRaises(errors.IncompatibleHardwareMethodError,
self.hardware.erase_block_device, block_device)
def test__is_virtual_media_device_exists(self, mocked_exists, mocked_link):
mocked_exists.return_value = True
mocked_link.return_value = '../../sda'
block_device = hardware.BlockDevice('/dev/sda', 'big', 1073741824,
True)
res = self.hardware._is_virtual_media_device(block_device)
self.assertTrue(res)
mocked_exists.assert_called_once_with('/dev/disk/by-label/ir-vfd-dev')
mocked_link.assert_called_once_with('/dev/disk/by-label/ir-vfd-dev')
def test__is_virtual_media_device_path_doesnt_exist(
self, mocked_exists, mocked_link):
mocked_exists.return_value = False
block_device = hardware.BlockDevice('/dev/sda', 'big', 1073741824,
True)
res = self.hardware._is_virtual_media_device(block_device)
self.assertFalse(res)
mocked_exists.assert_called_once_with('/dev/disk/by-label/ir-vfd-dev')
self.assertFalse(mocked_link.called)
def test__get_smartctl_attributes(self, mocked_execute):
expected = SMARTCTL_ATTRIBUTES
mocked_execute.return_value = SMARTCTL_ATTRIBUTES_OUT
self.block_device = hardware.BlockDevice('/dev/sda', '32G MLC SATADOM',
31016853504, False)
actual = self.hardware._get_smartctl_attributes(self.block_device)
mocked_execute.assert_called_once_with('smartctl', '--attributes',
'/dev/sda')
self.assertEqual(expected, actual)
def test_guess_root_disk_secondary_sort(self, mock_call):
block_devices = [
hardware.BlockDevice(name='/dev/sdc',
model='_',
size=10737418240,
rotational=True),
hardware.BlockDevice(name='/dev/sdb',
model='_',
size=10737418240,
rotational=True),
hardware.BlockDevice(name='/dev/sda',
model='_',
size=10737418240,
rotational=True),
hardware.BlockDevice(name='/dev/sdd',
model='_',
size=10737418240,
rotational=True),
]
device = utils.guess_root_disk(block_devices)
self.assertEqual(device.name, '/dev/sda')
