def test_filter_by_tags_returns_no_devices(self):
tags = [factory.make_name('tag') for _ in range(3)]
for _ in range(3):
factory.make_BlockDevice(tags=tags)
self.assertItemsEqual([],
BlockDevice.objects.filter_by_tags(
[factory.make_name('tag')]))
def _make_interesting_RAID(
node, level=FILESYSTEM_GROUP_TYPE.RAID_6, num_devices=10,
num_partitions=10, num_spare_devices=2, num_spare_partitions=2):
"""Returns a RAID that is interesting for our tests."""
size = 1000 ** 4 # A Terabyte.
block_devices = [factory.make_BlockDevice(node=node, size=size)
for _ in range(num_devices)]
partitions = [factory.make_Partition(node=node, block_device_size=size)
for _ in range(num_partitions)]
spare_devices = [factory.make_BlockDevice(node=node, size=size)
for _ in range(num_spare_devices)]
spare_partitions = [
factory.make_Partition(node=node, block_device_size=size)
for _ in range(num_spare_partitions)
]
return RAID.objects.create_raid(
name='md%d' % random.randint(1, 1000),
level=level,
uuid=uuid4(),
block_devices=block_devices,
partitions=partitions,
spare_devices=spare_devices,
spare_partitions=spare_partitions
)
def test_filter_by_tags_returns_devices_with_all_tags(self):
tags = [factory.make_name('tag') for _ in range(3)]
other_tags = [factory.make_name('tag') for _ in range(3)]
devices_with_tags = [
factory.make_BlockDevice(tags=tags) for _ in range(3)
]
for _ in range(3):
factory.make_BlockDevice(tags=other_tags)
self.assertItemsEqual(devices_with_tags,
BlockDevice.objects.filter_by_tags(tags))
def test_get_free_block_devices_for_node(self):
node = factory.make_Node(with_boot_disk=False)
free_devices = [factory.make_BlockDevice(node=node) for _ in range(3)]
# Block devices with partition tables.
for _ in range(3):
factory.make_PartitionTable(block_device=factory.make_BlockDevice(
node=node))
# Block devices with filesystems.
for _ in range(3):
factory.make_Filesystem(block_device=factory.make_BlockDevice(
node=node))
self.assertItemsEqual(
free_devices,
BlockDevice.objects.get_free_block_devices_for_node(node))
def test_user_cannot_view_BlockDevice_when_no_owner_rbac(self):
self.enable_rbac()
user = factory.make_User()
node = factory.make_Node()
device = factory.make_BlockDevice(node=node)
backend = MAASAuthorizationBackend()
self.assertFalse(backend.has_perm(user, NodePermission.view, device))
def test_fs_formatted(self):
block_device = factory.make_BlockDevice()
fs = factory.make_Filesystem(block_device=block_device)
self.assertEqual(
"Unmounted %s formatted filesystem" % fs.fstype,
used_for(block_device),
)
def test__raises_Http404_when_invalid_node(self):
user = factory.make_admin()
block_device = factory.make_BlockDevice()
self.assertRaises(
Http404, BlockDevice.objects.get_block_device_or_404,
factory.make_name("system_id"), block_device.id, user,
NodePermission.view)
def test__returns_device_when_admin(self):
user = factory.make_admin()
node = factory.make_Node()
device = factory.make_BlockDevice(node=node)
self.assertEqual(
device.id, BlockDevice.objects.get_block_device_or_404(
node.system_id, device.id, user, NodePermission.admin).id)
def test__edit_returns_device_when_user_is_owner(self):
user = factory.make_User()
node = factory.make_Node(owner=user)
device = factory.make_BlockDevice(node=node)
self.assertEqual(
device.id, BlockDevice.objects.get_block_device_or_404(
node.system_id, device.id, user, NodePermission.edit).id)
def test_admin_doesnt_have_admin_permission_on_BlockDevice_with_rbac(self):
self.enable_rbac()
backend = MAASAuthorizationBackend()
user = factory.make_admin()
node = factory.make_Node()
device = factory.make_BlockDevice(node=node)
self.assertFalse(backend.has_perm(user, NodePermission.admin, device))
def test_unique_on_block_device_and_acquired(self):
# For any given block device, at most one unacquired and one acquired
# filesystem record may exist.
block_device = factory.make_BlockDevice()
filesystem = factory.make_Filesystem(block_device=block_device)
self.assertIsNone(filesystem.partition)
# XXX: Why no Filesystem.acquire() method?
filesystem_acquired = copy(filesystem)
filesystem_acquired.id = None # Force INSERT.
filesystem_acquired.acquired = True
filesystem_acquired.save()
# Create a duplicate.
filesystem_dupe = copy(filesystem)
filesystem_dupe.id = None # Force INSERT.
error_messages_expected = Equals(
['Filesystem with this Block device and Acquired already exists.'])
# Saving an unacquired duplicate fails.
filesystem_dupe.acquired = False
error = self.assertRaises(ValidationError, filesystem_dupe.save)
self.assertThat(error.messages, error_messages_expected)
# Saving an acquired duplicate fails.
filesystem_dupe.acquired = True
error = self.assertRaises(ValidationError, filesystem_dupe.save)
self.assertThat(error.messages, error_messages_expected)
def test_validate_can_save_gpt_larger_than_2TiB(self):
block_device = factory.make_BlockDevice(size=3 * (1024 ** 4)) # 3TiB
partition_table = factory.make_PartitionTable(
block_device=block_device, table_type=PARTITION_TABLE_TYPE.GPT
)
# Test is that an error is not raised.
partition_table.add_partition()
def test_filter_by_tags_returns_devices_with_iterable(self):
tags = [factory.make_name('tag') for _ in range(3)]
other_tags = [factory.make_name('tag') for _ in range(3)]
devices_with_tags = [
factory.make_BlockDevice(tags=tags) for _ in range(3)
]
for _ in range(3):
factory.make_BlockDevice(tags=other_tags)
def tag_generator():
for tag in tags:
yield tag
self.assertItemsEqual(
devices_with_tags,
BlockDevice.objects.filter_by_tags(tag_generator()))
def test_get_effective_filesystem(self):
mock_get_effective_filesystem = self.patch_autospec(
blockdevice_module, "get_effective_filesystem")
mock_get_effective_filesystem.return_value = sentinel.filesystem
block_device = factory.make_BlockDevice()
self.assertEqual(sentinel.filesystem,
block_device.get_effective_filesystem())
def test__view_raises_PermissionDenied_when_user_not_owner(self):
user = factory.make_User()
node = factory.make_Node(owner=factory.make_User())
device = factory.make_BlockDevice(node=node)
self.assertRaises(PermissionDenied,
BlockDevice.objects.get_block_device_or_404,
node.system_id, device.id, user, NodePermission.view)
def test_get_effective_filesystem(self):
mock_get_effective_filesystem = self.patch_autospec(
blockdevice_module, "get_effective_filesystem")
mock_get_effective_filesystem.return_value = sentinel.filesystem
node = factory.make_Node(with_boot_disk=False)
block_device = factory.make_BlockDevice(node=node)
self.assertEqual(sentinel.filesystem,
block_device.get_effective_filesystem())
def test__raises_PermissionDenied_when_user_requests_admin(self):
user = factory.make_User()
node = factory.make_Node()
device = factory.make_BlockDevice(node=node)
self.assertRaises(PermissionDenied,
BlockDevice.objects.get_block_device_or_404,
node.system_id, device.id, user,
NodePermission.admin)
def test__admin_returns_device_when_admin(self):
user = factory.make_admin()
node = factory.make_Node()
device = factory.make_BlockDevice(node=node)
self.assertEqual(
device.id,
BlockDevice.objects.get_block_device_or_404(
node.system_id, device.id, user, NODE_PERMISSION.ADMIN).id)
def test_remove_invalid_spare_blockdevice_fails(self):
raid = _make_interesting_RAID(node=factory.make_Node())
ids = [factory.make_BlockDevice().id for _ in range(2)]
form = UpdateRaidForm(raid, data={'remove_spare_devices': ids})
self.assertFalse(form.is_valid(), form.errors)
self.assertIn('remove_spare_devices', form.errors)
self.assertIn('is not one of the available choices.',
form.errors['remove_spare_devices'][0])
def test_delete_not_allowed_if_part_of_filesystem_group(self):
block_device = factory.make_BlockDevice()
VolumeGroup.objects.create_volume_group(factory.make_name("vg"),
[block_device], [])
error = self.assertRaises(ValidationError, block_device.delete)
self.assertEqual(
"Cannot delete block device because its part of a volume group.",
error.message)
def test_add_valid_spare_device(self):
raid = factory.make_FilesystemGroup(
group_type=FILESYSTEM_GROUP_TYPE.RAID_6)
# Add 5 new blockdevices to the node.
bd_ids = [factory.make_BlockDevice(node=raid.get_node()).id
for _ in range(5)]
form = UpdateRaidForm(raid, data={'add_spare_devices': bd_ids})
self.assertTrue(form.is_valid(), form.errors)
def test_user_has_no_admin_permission_on_BlockDevice(self):
# NodePermission.admin permission on block devices is granted to super
# user only.
backend = MAASAuthorizationBackend()
user = factory.make_User()
self.assertFalse(
backend.has_perm(user, NodePermission.admin,
factory.make_BlockDevice()))
def test_user_cannot_edit_BlockDevice_rbac_if_locked(self):
self.enable_rbac()
user = factory.make_User()
node = factory.make_Node(locked=True)
device = factory.make_BlockDevice(node=node)
self.rbac_store.add_pool(node.pool)
self.rbac_store.allow(user.username, node.pool, 'admin-machine')
backend = MAASAuthorizationBackend()
self.assertFalse(backend.has_perm(user, NodePermission.edit, device))
def test_get_available_size(self):
block_size = 4096
device = factory.make_BlockDevice(size=MIN_PARTITION_SIZE * 3 +
PARTITION_TABLE_EXTRA_SPACE,
block_size=block_size)
partition_table = factory.make_PartitionTable(block_device=device)
partition_table.add_partition(size=MIN_PARTITION_SIZE)
self.assertEqual(MIN_PARTITION_SIZE * 2,
partition_table.get_available_size())
def test_user_cannot_lock_BlockDevice_node_rbac_owner_other_user(self):
self.enable_rbac()
user = factory.make_User()
node = factory.make_Node(owner=factory.make_User())
device = factory.make_BlockDevice(node=node)
backend = MAASAuthorizationBackend()
self.rbac_store.add_pool(node.pool)
self.rbac_store.allow(user.username, node.pool, 'view')
self.assertFalse(backend.has_perm(user, NodePermission.lock, device))
def test_user_has_admin_permission_on_BlockDevice_with_rbac(self):
self.enable_rbac()
backend = MAASAuthorizationBackend()
user = factory.make_User()
node = factory.make_Node()
device = factory.make_BlockDevice(node=node)
self.rbac_store.add_pool(node.pool)
self.rbac_store.allow(user.username, node.pool, 'admin-machines')
self.assertTrue(backend.has_perm(user, NodePermission.admin, device))
def test_user_can_view_BlockDevice_on_unowned_node_rbac(self):
self.enable_rbac()
user = factory.make_User()
node = factory.make_Node()
device = factory.make_BlockDevice(node=node)
self.rbac_store.add_pool(node.pool)
self.rbac_store.allow(user.username, node.pool, 'view')
backend = MAASAuthorizationBackend()
self.assertTrue(backend.has_perm(user, NodePermission.view, device))
def test_fs_formatted_and_mounted(self):
block_device = factory.make_BlockDevice()
fs = factory.make_Filesystem(block_device=block_device,
mount_point="/mnt")
self.assertEqual(
("%s formatted filesystem mounted at %s" %
(fs.fstype, fs.mount_point)),
used_for(block_device),
)
def test_add_partition_no_size(self):
"""Tests whether a partition with no specified size stretches to the
end of the device"""
block_size = 4096
device = factory.make_BlockDevice(size=MIN_BLOCK_DEVICE_SIZE * 2 +
PARTITION_TABLE_EXTRA_SPACE,
block_size=block_size)
partition_table = factory.make_PartitionTable(block_device=device)
partition = partition_table.add_partition()
self.assertEqual(partition.size, MIN_BLOCK_DEVICE_SIZE * 2)
def test_add_partition_to_full_device(self):
"""Tests whether we fail to add a partition to an already full device.
"""
block_size = 4096
device = factory.make_BlockDevice(size=MIN_BLOCK_DEVICE_SIZE * 3 +
PARTITION_TABLE_EXTRA_SPACE,
block_size=block_size)
partition_table = factory.make_PartitionTable(block_device=device)
partition_table.add_partition()
self.assertRaises(ValidationError, partition_table.add_partition)
