def test_run(self, *args):
"""Test multipath device populator."""
device_get_name = args[0]
add_slave_devices = args[1]
devicetree = DeviceTree()
# set up some fake udev data to verify handling of specific entries
data = Mock()
_data = {"ID_WWN": "0x5000c50086fb75ca", "DM_UUID": "1-2-3-4"}
def _getitem_(key, extra=None):
return _data.get(key, extra)
data.get = Mock(side_effect=_getitem_)
data.__getitem__ = Mock(side_effect=_getitem_)
device_name = "mpathtest"
device_get_name.return_value = device_name
slave_1 = Mock(tags=set())
slave_1.parents = []
slave_2 = Mock(tags=set())
slave_2.parents = []
devicetree._add_device(slave_1)
devicetree._add_device(slave_2)
add_slave_devices.return_value = [slave_1, slave_2]
helper = self.helper_class(devicetree, data)
device = helper.run()
self.assertIsInstance(device, MultipathDevice)
self.assertTrue(device.exists)
self.assertEqual(device.name, device_name)
self.assertEqual(device.wwn, _data["ID_WWN"])
self.assertTrue(device in devicetree.devices)
def setUp(self, *args):
self._device_id = random.randint(0, 500)
self._format_id = random.randint(501, 1000)
self.obj = DBusDevice(Mock(name="StorageDevice", id=self._device_id,
parents=[], children=[]),
Mock(name="ObjectManager"))
self.obj._manager.get_object_by_id.return_value = Mock(name="DBusObject", object_path="/an/object/path")
def test_match(self, *args):
"""Test matching for disklabel format populator."""
device_get_disklabel_type = args[0]
device_get_format = args[1]
device_is_biosraid_member = args[2]
is_mpath_member = args[3]
device = Mock()
device.is_disk = True
data = Mock()
self.assertTrue(self.helper_class.match(data, device))
# ID_PART_TABLE_TYPE is required in udev data
device_get_disklabel_type.return_value = None
self.assertFalse(self.helper_class.match(data, device))
device_get_disklabel_type.return_value = "dos"
# no match for whole-disk iso9660 filesystems (isohybrid media)
device_get_format.return_value = "iso9660"
self.assertFalse(self.helper_class.match(data, device))
device_get_format.return_value = None
# no match for biosraid members
device_is_biosraid_member.return_value = True
self.assertFalse(self.helper_class.match(data, device))
device_is_biosraid_member.return_value = False
# no match for multipath members
is_mpath_member.return_value = True
self.assertFalse(self.helper_class.match(data, device))
is_mpath_member.return_value = False
def mock_protocol():
mproto = Mock(RPCProtocol)
foo = Mock(RPCResponse)
foo.result = None
mproto.parse_reply = Mock(return_value=foo)
return mproto
def _ctor_kwargs(self):
kwargs = super(LVMLogicalVolumeDeviceMethodsTestCase, self)._ctor_kwargs()
vg_mock = Mock(name="testvg", spec=LVMVolumeGroupDevice)
vg_mock.name = "testvg"
vg_mock.pvs = vg_mock.parents = [Mock(name="pv.1", protected=False)]
vg_mock.protected = False
vg_mock.readonly = False
kwargs["parents"] = [vg_mock]
kwargs["pvs"] = []
return kwargs
def test_dispatch_calls_method_and_responds(dispatch, mock_request):
m = Mock()
m.subtract = Mock(return_value=-2)
dispatch.add_method(m.subtract, 'subtract')
response = dispatch.dispatch(mock_request)
assert m.subtract.called
mock_request.respond.assert_called_with(-2)
def test_chunk(self):
dev1 = Mock()
attrs = {"req_grow": True, "id": 1, "name": "req1"}
dev1.configure_mock(**attrs)
req1 = Request(dev1)
req1.base = 10
dev2 = Mock()
attrs = {"req_grow": False, "id": 2, "name": "req2"}
dev2.configure_mock(**attrs)
req2 = Request(dev2)
req2.base = 20
chunk = Chunk(110, requests=[req1, req2])
self.assertEqual(chunk.pool, 80)
self.assertEqual(chunk.base, 10)
dev3 = Mock()
attrs = {"req_grow": True, "id": 3, "name": "req3"}
dev3.configure_mock(**attrs)
req3 = Request(dev3)
req3.base = 20
req3.max_growth = 35
chunk.add_request(req3)
self.assertEqual(chunk.pool, 60)
self.assertEqual(chunk.base, 30)
self.assertEqual(chunk.length_to_size(30), 30)
self.assertEqual(chunk.size_to_length(40), 40)
self.assertEqual(chunk.has_growable, True)
chunk.grow_requests()
# the chunk is done growing since its pool has been exhausted
self.assertEqual(chunk.done, True)
# there is still one request remaining since req1 has no maximum growth
self.assertEqual(chunk.remaining, 1)
# req1 is 10 units and growable with no limit
# req2 is 20 units and not growable
# req3 is 20 units and growable with a limits of 35 units of growth
#
# Requests are grown at rates proportional to their share of the
# combined base size of all growable requests. If req3 had no max growth
# it would get 40 units and req1 would get 20. Since req3 has a limit,
# it will get 35 and req1 will get its 20 plus the leftovers from req3,
# which comes out to 25.
self.assertEqual(req1.growth, 25)
self.assertEqual(req2.growth, 0)
self.assertEqual(req3.growth, 35)
def _ctor_kwargs(self):
kwargs = super(MDRaidArrayDeviceMethodsTestCase, self)._ctor_kwargs()
kwargs["level"] = "raid0"
kwargs["parents"] = [Mock(name="member1", spec=StorageDevice),
Mock(name="member2", spec=StorageDevice)]
mdmember = get_device_format_class("mdmember")
for member in kwargs["parents"]:
member.format = Mock(spec=mdmember, exists=True)
member.protected = False
member.readonly = False
return kwargs
def test_align_free_regions(self):
# disk with two free regions -- first unaligned, second aligned
disk = Mock()
disk.format.alignment.grainSize = 2048
disk.format.parted_disk.getFreeSpaceRegions.return_value = [Mock(start=1, end=2049, length=2049),
Mock(start=1, end=2048, length=2048)]
free = get_free_regions([disk])
self.assertEqual(free[0].length, 2049)
self.assertEqual(free[1].length, 2048)
free = get_free_regions([disk], align=True)
self.assertEqual(free[0].length, 2048)
self.assertEqual(free[1].length, 2048)
def test_dispatch_handles_in_function_exceptions(dispatch, mock_request):
m = Mock()
m.subtract = Mock(return_value=-2)
class MockError(Exception):
pass
m.subtract.side_effect = MockError('mock error')
dispatch.add_method(m.subtract, 'subtract')
response = dispatch.dispatch(mock_request)
assert m.subtract.called
mock_request.error_respond.assert_called_with(m.subtract.side_effect)
def client(mock_protocol, mock_transport, request):
client = RPCClient(mock_protocol, mock_transport, NoOpPublisher())
client.wait_for_task = Mock(return_value=None)
response = Mock(RPCResponse)
response.unicode = '0'
response.result = 'result1'
client.get_status = Mock(return_value={
response.unicode: ('done', response, 'some time', 'timeout')
})
def fin():
client.receiver.alive = False
request.addfinalizer(fin)
return client
def test_client_uses_correct_transport(client, mock_protocol, method_name,
method_args, method_kwargs,
async_kwargs, mock_transport):
req = Mock(RPCRequest)
req.unique_id = '0'
req.method = 'test_method'
req.callback = async_kwargs['callback']
req.sync = async_kwargs[
'asynchronize'] if 'asynchronize' in async_kwargs else True
req.args = method_args
req.kwargs = method_kwargs
mock_protocol.create_request = Mock(return_value=req)
method_kwargs.update(async_kwargs)
client.call(method_name, method_args, method_kwargs)
assert mock_transport.send_message.called
def test_class_method_argument_error(dispatch, invoke_with):
method, args, kwargs, result = invoke_with
protocol = JSONRPCProtocol()
class Test:
c = 0
@classmethod
@public
def fn_a(cls, a, b):
return a - b - cls.c
@classmethod
@public
def fn_b(cls, *a):
return a[0] - a[1] - cls.c
@classmethod
@public
def fn_c(cls, **a):
return a['a'] - a['b'] - cls.c
test = Test()
dispatch.register_instance(test)
mock_request = Mock(RPCRequest)
mock_request.args = args
mock_request.kwargs = kwargs
mock_request.method = method
dispatch._dispatch(mock_request, getattr(protocol, '_caller', None))
if inspect.isclass(result) and issubclass(result, Exception):
assert type(mock_request.error_respond.call_args[0][0]) == result
else:
mock_request.respond.assert_called_with(result)
def test_get_helper(self, *args):
"""Test get_format_helper for disklabels."""
device_get_disklabel_type = args[0]
device = Mock()
device.is_disk = True
data = Mock()
self.assertEqual(get_format_helper(data, device), self.helper_class)
# no disklabel type reported by udev/blkid -> get_format_helper does not return
# disklabel helper
device_get_disklabel_type.return_value = None
self.assertNotEqual(get_format_helper(data, device), self.helper_class)
device_get_disklabel_type.return_value = "dos"
def test_client_passes_correct_reply(client, mock_protocol, method_name,
method_args, method_kwargs,
one_way_setting, mock_transport):
transport_return = '023hoisdfh'
mock_transport.send_message = Mock(return_value=transport_return)
client.call(method_name, method_args, method_kwargs, one_way_setting)
mock_protocol.parse_reply.assert_called_with(transport_return)
def test_run(self, *args):
"""Test loop device populator."""
device_get_name = args[1]
get_backing_file = args[2]
devicetree = DeviceTree()
data = Mock()
# Add backing file and loop device.
devicetree.get_device_by_name.return_value = None
device_name = "loop3"
device_get_name.return_value = device_name
backing_file = "/some/file"
get_backing_file.return_value = None
helper = self.helper_class(devicetree, data)
device = helper.run()
self.assertIsNone(device)
get_backing_file.return_value = backing_file
device = helper.run()
self.assertIsInstance(device, LoopDevice)
self.assertTrue(device in devicetree.devices)
self.assertTrue(device.exists)
self.assertEqual(device.name, device_name)
self.assertIsInstance(device.parents[0], FileDevice)
self.assertTrue(device.parents[0].exists)
self.assertEqual(devicetree.get_device_by_name.call_count, 1) # pylint: disable=no-member
devicetree.get_device_by_name.assert_called_with(backing_file) # pylint: disable=no-member
def test_argument_error(dispatch, invoke_with):
method, args, kwargs, result = invoke_with
protocol = JSONRPCProtocol()
@dispatch.public
def fn_a(a, b):
return a - b
@dispatch.public
def fn_b(*a):
return a[0] - a[1]
@dispatch.public
def fn_c(**a):
return a['a'] - a['b']
mock_request = Mock(RPCRequest)
mock_request.args = args
mock_request.kwargs = kwargs
mock_request.method = method
dispatch._dispatch(mock_request, getattr(protocol, '_caller', None))
if inspect.isclass(result) and issubclass(result, Exception):
assert type(mock_request.error_respond.call_args[0][0]) == result
else:
mock_request.respond.assert_called_with(result)
def mock_request(method='subtract', args=None, kwargs=None):
mock_request = Mock(RPCRequest)
mock_request.method = method
mock_request.args = args or [4, 6]
mock_request.kwargs = kwargs or {}
return mock_request
def testEventMask(self):
handler_cb = Mock()
with patch("blivet.events.manager.validate_cb", return_value=True):
mgr = FakeEventManager(handler_cb=handler_cb)
device = "sdc"
action = "add"
mgr.handle_event(action, device)
time.sleep(1)
self.assertEqual(handler_cb.call_count, 1)
event = handler_cb.call_args[1]["event"] # pylint: disable=unsubscriptable-object
self.assertEqual(event.device, device)
self.assertEqual(event.action, action)
# mask matches device but not action -> event is handled
handler_cb.reset_mock()
mask = mgr.add_mask(device=device, action=action + 'x')
mgr.handle_event(action, device)
time.sleep(1)
self.assertEqual(handler_cb.call_count, 1)
event = handler_cb.call_args[1]["event"] # pylint: disable=unsubscriptable-object
self.assertEqual(event.device, device)
self.assertEqual(event.action, action)
# mask matches action but not device -> event is handled
handler_cb.reset_mock()
mask = mgr.add_mask(device=device + 'x', action=action)
mgr.handle_event(action, device)
time.sleep(1)
self.assertEqual(handler_cb.call_count, 1)
event = handler_cb.call_args[1]["event"] # pylint: disable=unsubscriptable-object
self.assertEqual(event.device, device)
self.assertEqual(event.action, action)
# mask matches device and action -> event is ignored
handler_cb.reset_mock()
mgr.remove_mask(mask)
mask = mgr.add_mask(device=device, action=action)
mgr.handle_event(action, device)
time.sleep(1)
self.assertEqual(handler_cb.call_count, 0)
# device-only mask matches -> event is ignored
handler_cb.reset_mock()
mgr.remove_mask(mask)
mask = mgr.add_mask(device=device)
mgr.handle_event(action, device)
time.sleep(1)
self.assertEqual(handler_cb.call_count, 0)
# action-only mask matches -> event is ignored
handler_cb.reset_mock()
mgr.remove_mask(mask)
mask = mgr.add_mask(action=action)
mgr.handle_event(action, device)
time.sleep(1)
self.assertEqual(handler_cb.call_count, 0)
mgr.remove_mask(mask)
def test_client_raises_error_replies(client, mock_protocol, method_name,
method_args, method_kwargs,
one_way_setting):
error_response = RPCErrorResponse()
error_response.error = 'foo'
mock_protocol.parse_reply = Mock(return_value=error_response)
with pytest.raises(RPCError):
client.call(method_name, method_args, method_kwargs, one_way_setting)
def test_client_raises_error_replies(client, mock_protocol, method_name,
method_args, method_kwargs, async_kwargs):
method_kwargs.update(async_kwargs)
error_response = RPCResponse()
error_response.error = 'foo'
client._send_and_handle_reply = Mock(return_value=error_response)
with pytest.raises(RPCError):
client.call(method_name, method_args, method_kwargs)
def test_run(self, *args):
"""Test md device populator."""
device_get_md_name = args[0]
get_device_by_name = args[4]
devicetree = DeviceTree()
# base case: _add_slave_devices gets the array into the tree
data = Mock()
device = Mock()
device.parents = []
device_name = "mdtest"
device_get_md_name.return_value = device_name
get_device_by_name.return_value = device
helper = self.helper_class(devicetree, data)
self.assertEqual(helper.run(), device)
def test_msdos_disk_chunk1(self):
disk_size = Size("100 MiB")
with sparsetmpfile("chunktest", disk_size) as disk_file:
disk = DiskFile(disk_file)
disk.format = get_format("disklabel",
device=disk.path,
exists=False,
label_type="msdos")
p1 = PartitionDevice("p1", size=Size("10 MiB"), grow=True)
p2 = PartitionDevice("p2", size=Size("30 MiB"), grow=True)
disks = [disk]
partitions = [p1, p2]
free = get_free_regions([disk])
self.assertEqual(len(free), 1,
"free region count %d not expected" % len(free))
b = Mock(spec=Blivet)
allocate_partitions(b, disks, partitions, free)
requests = [PartitionRequest(p) for p in partitions]
chunk = DiskChunk(free[0], requests=requests)
# parted reports a first free sector of 32 for msdos on disk files. whatever.
# XXX on gpt, the start is increased to 34 and the end is reduced from 204799 to 204766,
# yielding an expected length of 204733
length_expected = 204768
self.assertEqual(chunk.length, length_expected)
base_expected = sum(p.parted_partition.geometry.length
for p in partitions)
self.assertEqual(chunk.base, base_expected)
pool_expected = chunk.length - base_expected
self.assertEqual(chunk.pool, pool_expected)
self.assertEqual(chunk.done, False)
self.assertEqual(chunk.remaining, 2)
chunk.grow_requests()
self.assertEqual(chunk.done, True)
self.assertEqual(chunk.pool, 0)
self.assertEqual(chunk.remaining, 2)
#
# validate the growth (everything in sectors)
#
# The chunk length is 204768. The base of p1 is 20480. The base of
# p2 is 61440. The chunk has a base of 81920 and a pool of 122848.
#
# p1 should grow by 30712 while p2 grows by 92136 since p2's base
# size is exactly three times that of p1.
self.assertEqual(requests[0].growth, 30712)
self.assertEqual(requests[1].growth, 92136)
def test_client_passes_correct_reply(client, mock_protocol, method_name,
method_args, method_kwargs, async_kwargs,
mock_transport):
req = Mock(RPCRequest)
req.unique_id = '0'
req.method = 'test_method'
req.callback = async_kwargs['callback']
req.sync = async_kwargs[
'asynchronize'] if 'asynchronize' in async_kwargs else True
req.args = method_args
req.kwargs = method_kwargs
method_kwargs.update(async_kwargs)
mock_protocol.create_request = Mock(return_value=req)
transport_return = '023hoisdfh'
client.receiver.transport.receive_reply = Mock(
return_value=transport_return)
time.sleep(0.1)
client.call(method_name, method_args, method_kwargs)
mock_protocol.parse_reply.assert_called_with(transport_return)
def test_client_send_binary_message(client, mock_protocol, method_name,
method_args, method_kwargs,
one_way_setting, mock_transport):
req = Mock(RPCRequest)
req.serialize.return_value = u'unicode not acceptable'
mock_protocol.create_request.return_value = req
client.call(method_name, method_args, method_kwargs, one_way_setting)
assert mock_transport.send_message.called
assert isinstance(mock_transport.send_message.call_args[0][0],
six.binary_type)
def test_handle_message_callback(transport, protocol, dispatcher):
server = RPCServer(transport, protocol, dispatcher)
server.trace = Mock(return_value=None)
server.receive_one_message()
assert server.trace.call_args_list == [
call('-->', CONTEXT, RECMSG),
call('<--', CONTEXT, SERMSG)
]
server.trace.assert_called()
def test_weight_2(self):
for spec in weighted:
part = PartitionDevice('weight_test')
part._format = Mock(name="fmt", type=spec.fstype, mountpoint=spec.mountpoint,
mountable=spec.mountpoint is not None)
with patch('blivet.devices.partition.arch') as _arch:
for func in arch_funcs:
f = getattr(_arch, func)
f.return_value = func in spec.true_funcs
self.assertEqual(part.weight, spec.weight)
def test_match(self):
if self.udev_type is None:
return
data = dict()
device = Mock()
with patch("blivet.udev.device_get_format",
return_value=self.udev_type):
self.assertTrue(self.helper_class.match(data, device),
msg="Failed to match %s against %s" %
(self.udev_type, self.helper_name))
def get_disk(self, disk_type, primary_count=0,
has_extended=False, logical_count=0):
""" Return a mock representing a parted.Disk. """
disk = Mock()
disk.type = disk_type
label_type_info = disklabel_types[disk_type]
(max_primaries, supports_extended) = label_type_info
# primary partitions
disk.primaryPartitionCount = primary_count
disk.maxPrimaryPartitionCount = max_primaries
# extended partitions
disk.supportsFeature = Mock(return_value=supports_extended)
disk.getExtendedPartition = Mock(return_value=has_extended)
# logical partitions
disk.getLogicalPartitions = Mock(return_value=[0] * logical_count)
return disk
def test_run(self, *args):
"""Test lvm device populator."""
device_get_lv_vg_name = args[0]
device_get_name = args[1]
get_device_by_name = args[3]
devicetree = DeviceTree()
data = Mock()
# Add slave/parent devices and then look up the device.
device_get_name.return_value = sentinel.lv_name
devicetree.get_device_by_name.return_value = None
# pylint: disable=unused-argument
def _get_device_by_name(name, **kwargs):
if name == sentinel.lv_name:
return sentinel.lv_device
get_device_by_name.side_effect = _get_device_by_name
device_get_lv_vg_name.return_value = sentinel.vg_name
helper = self.helper_class(devicetree, data)
self.assertEqual(helper.run(), sentinel.lv_device)
self.assertEqual(devicetree.get_device_by_name.call_count, 3) # pylint: disable=no-member
get_device_by_name.assert_has_calls([
call(sentinel.vg_name, hidden=True),
call(sentinel.vg_name),
call(sentinel.lv_name)
])
# Add slave/parent devices, but the device is still not in the tree
get_device_by_name.side_effect = None
get_device_by_name.return_value = None
self.assertEqual(helper.run(), None)
get_device_by_name.assert_called_with(sentinel.lv_name)
# A non-vg device with the same name as the vg is already in the tree.
# pylint: disable=unused-argument
def _get_device_by_name2(name, **kwargs):
if name == sentinel.lv_name:
return sentinel.lv_device
elif name == sentinel.vg_name:
return sentinel.non_vg_device
get_device_by_name.side_effect = _get_device_by_name2
if six.PY3:
with self.assertLogs('blivet', level='WARNING') as log_cm:
self.assertEqual(helper.run(), sentinel.lv_device)
log_entry = "WARNING:blivet:found non-vg device with name %s" % sentinel.vg_name
self.assertTrue(log_entry in log_cm.output)
else:
self.assertEqual(helper.run(), sentinel.lv_device)
