def test_get_name_returns_concat_volume_group_name(self):
name = factory.make_name("lv")
vgname = factory.make_name("vg")
volume_group = factory.make_VolumeGroup(name=vgname)
logical_volume = factory.make_VirtualBlockDevice(
name=name, filesystem_group=volume_group)
self.assertEqual("%s-%s" % (vgname, name), logical_volume.get_name())
def test_create_logical_volume_creates_logical_volume(self):
self.become_admin()
node = factory.make_Node(status=NODE_STATUS.READY)
volume_group = factory.make_VolumeGroup(node=node)
name = factory.make_name("lv")
vguuid = "%s" % uuid.uuid4()
size = random.randint(MIN_BLOCK_DEVICE_SIZE, volume_group.get_size())
uri = get_volume_group_uri(volume_group)
response = self.client.post(
uri,
{
"op": "create_logical_volume",
"name": name,
"uuid": vguuid,
"size": size,
},
)
self.assertEqual(http.client.OK, response.status_code,
response.content)
logical_volume = json.loads(
response.content.decode(settings.DEFAULT_CHARSET))
expected_size = round_size_to_nearest_block(size,
PARTITION_ALIGNMENT_SIZE,
False)
self.assertThat(
logical_volume,
ContainsDict({
"name": Equals("%s-%s" % (volume_group.name, name)),
"uuid": Equals(vguuid),
"size": Equals(expected_size),
}),
)
def test_create_logical_volume_403_when_not_admin(self):
node = factory.make_Node(status=NODE_STATUS.READY)
volume_group = factory.make_VolumeGroup(node=node)
uri = get_volume_group_uri(volume_group)
response = self.client.post(uri, {"op": "create_logical_volume"})
self.assertEqual(http.client.FORBIDDEN, response.status_code,
response.content)
def test_is_not_valid_if_invalid_uuid(self):
volume_group = factory.make_VolumeGroup()
data = {"uuid": factory.make_string(size=32)}
form = UpdateVolumeGroupForm(volume_group, data=data)
self.assertFalse(form.is_valid(),
"Should be invalid because of an invalid uuid.")
self.assertEqual({"uuid": ["Enter a valid value."]}, form._errors)
def test_create_logical_volume_409_when_not_ready(self):
self.become_admin()
node = factory.make_Node(status=NODE_STATUS.ALLOCATED)
volume_group = factory.make_VolumeGroup(node=node)
uri = get_volume_group_uri(volume_group)
response = self.client.post(uri, {"op": "create_logical_volume"})
self.assertEqual(http.client.CONFLICT, response.status_code,
response.content)
def test_delete_logical_volume_400_when_missing_id(self):
self.become_admin()
node = factory.make_Node(status=NODE_STATUS.READY)
volume_group = factory.make_VolumeGroup(node=node)
uri = get_volume_group_uri(volume_group)
response = self.client.post(uri, {"op": "delete_logical_volume"})
self.assertEqual(http.client.BAD_REQUEST, response.status_code,
response.content)
def test_updates_name(self):
volume_group = factory.make_VolumeGroup()
name = factory.make_name("vg")
data = {"name": name}
form = UpdateVolumeGroupForm(volume_group, data=data)
self.assertTrue(form.is_valid(), form._errors)
volume_group = form.save()
self.assertEqual(name, volume_group.name)
def test_updates_uuid(self):
volume_group = factory.make_VolumeGroup()
vguuid = "%s" % uuid.uuid4()
data = {"uuid": vguuid}
form = UpdateVolumeGroupForm(volume_group, data=data)
self.assertTrue(form.is_valid(), form._errors)
volume_group = form.save()
self.assertEqual(vguuid, volume_group.uuid)
def test_delete_deletes_volume_group(self):
self.become_admin()
node = factory.make_Node(status=NODE_STATUS.READY)
volume_group = factory.make_VolumeGroup(node=node)
uri = get_volume_group_uri(volume_group)
response = self.client.delete(uri)
self.assertEqual(http.client.NO_CONTENT, response.status_code,
response.content)
self.assertIsNone(reload_object(volume_group))
def test_update_updates_volume_group(self):
self.become_admin()
node = factory.make_Node(status=NODE_STATUS.READY)
volume_group = factory.make_VolumeGroup(node=node)
delete_block_device = factory.make_PhysicalBlockDevice(node=node)
factory.make_Filesystem(
fstype=FILESYSTEM_TYPE.LVM_PV,
block_device=delete_block_device,
filesystem_group=volume_group,
)
delete_bd_for_partition = factory.make_PhysicalBlockDevice(node=node)
delete_table = factory.make_PartitionTable(
block_device=delete_bd_for_partition
)
delete_partition = factory.make_Partition(partition_table=delete_table)
factory.make_Filesystem(
fstype=FILESYSTEM_TYPE.LVM_PV,
partition=delete_partition,
filesystem_group=volume_group,
)
new_name = factory.make_name("vg")
new_uuid = "%s" % uuid.uuid4()
new_block_device = factory.make_PhysicalBlockDevice(node=node)
new_bd_for_partition = factory.make_PhysicalBlockDevice(node=node)
new_table = factory.make_PartitionTable(
block_device=new_bd_for_partition
)
new_partition = factory.make_Partition(partition_table=new_table)
uri = get_volume_group_uri(volume_group)
response = self.client.put(
uri,
{
"name": new_name,
"uuid": new_uuid,
"add_block_devices": [new_block_device.id],
"remove_block_devices": [delete_block_device.id],
"add_partitions": [new_partition.id],
"remove_partitions": [delete_partition.id],
},
)
self.assertEqual(
http.client.OK, response.status_code, response.content
)
volume_group = reload_object(volume_group)
self.assertEqual(new_name, volume_group.name)
self.assertEqual(new_uuid, volume_group.uuid)
self.assertEqual(
volume_group.id,
new_block_device.get_effective_filesystem().filesystem_group.id,
)
self.assertEqual(
volume_group.id,
new_partition.get_effective_filesystem().filesystem_group.id,
)
self.assertIsNone(delete_block_device.get_effective_filesystem())
self.assertIsNone(delete_partition.get_effective_filesystem())
def test_delete_logical_volume_204_when_invalid_id(self):
self.become_admin()
node = factory.make_Node(status=NODE_STATUS.READY)
volume_group = factory.make_VolumeGroup(node=node)
uri = get_volume_group_uri(volume_group)
volume_id = random.randint(0, 100)
response = self.client.post(uri, {
"op": "delete_logical_volume",
"id": volume_id
})
self.assertEqual(http.client.NO_CONTENT, response.status_code,
response.content)
def test_delete_logical_volume_403_when_not_admin(self):
node = factory.make_Node(status=NODE_STATUS.READY)
volume_group = factory.make_VolumeGroup(node=node)
logical_volume = factory.make_VirtualBlockDevice(
filesystem_group=volume_group)
uri = get_volume_group_uri(volume_group)
response = self.client.post(uri, {
"op": "delete_logical_volume",
"id": logical_volume.id
})
self.assertEqual(http.client.FORBIDDEN, response.status_code,
response.content)
def test_is_not_valid_if_invalid_uuid(self):
volume_group = factory.make_VolumeGroup()
name = factory.make_name("lv")
data = {
'name': name,
'uuid': factory.make_string(size=32),
'size': volume_group.get_size() - 1,
}
form = CreateLogicalVolumeForm(volume_group, data=data)
self.assertFalse(form.is_valid(),
"Should be invalid because of an invalid uuid.")
self.assertEqual({'uuid': ["Enter a valid value."]}, form._errors)
def test_adds_block_device_by_name(self):
node = factory.make_Node()
volume_group = factory.make_VolumeGroup(node=node)
block_device = factory.make_PhysicalBlockDevice(node=node)
data = {"add_block_devices": [block_device.name]}
form = UpdateVolumeGroupForm(volume_group, data=data)
self.assertTrue(form.is_valid(), form._errors)
volume_group = form.save()
self.assertEqual(
volume_group.id,
block_device.get_effective_filesystem().filesystem_group.id,
)
def test_delete_logical_volume_409_when_not_ready(self):
self.become_admin()
node = factory.make_Node(status=NODE_STATUS.ALLOCATED)
volume_group = factory.make_VolumeGroup(node=node)
logical_volume = factory.make_VirtualBlockDevice(
filesystem_group=volume_group)
uri = get_volume_group_uri(volume_group)
response = self.client.post(uri, {
"op": "delete_logical_volume",
"id": logical_volume.id
})
self.assertEqual(http.client.CONFLICT, response.status_code,
response.content)
def test_adds_boot_disk(self):
node = factory.make_Node(with_boot_disk=False)
boot_disk = factory.make_PhysicalBlockDevice(node=node)
volume_group = factory.make_VolumeGroup(node=node)
data = {"add_block_devices": [boot_disk.id]}
form = UpdateVolumeGroupForm(volume_group, data=data)
self.assertTrue(form.is_valid(), form._errors)
volume_group = form.save()
boot_partition = boot_disk.get_partitiontable().partitions.first()
self.assertEqual(
boot_partition.get_effective_filesystem().filesystem_group.id,
volume_group.id,
)
def test_removes_block_device_by_name(self):
node = factory.make_Node()
volume_group = factory.make_VolumeGroup(node=node)
block_device = factory.make_PhysicalBlockDevice(node=node)
factory.make_Filesystem(fstype=FILESYSTEM_TYPE.LVM_PV,
block_device=block_device,
filesystem_group=volume_group)
data = {
'remove_block_devices': [block_device.name],
}
form = UpdateVolumeGroupForm(volume_group, data=data)
self.assertTrue(form.is_valid(), form._errors)
volume_group = form.save()
self.assertIsNone(block_device.get_effective_filesystem())
def test_delete_logical_volume_deletes_logical_volume(self):
self.become_admin()
node = factory.make_Node(status=NODE_STATUS.READY)
volume_group = factory.make_VolumeGroup(node=node)
logical_volume = factory.make_VirtualBlockDevice(
filesystem_group=volume_group)
uri = get_volume_group_uri(volume_group)
response = self.client.post(uri, {
"op": "delete_logical_volume",
"id": logical_volume.id
})
self.assertEqual(http.client.NO_CONTENT, response.status_code,
response.content)
self.assertIsNone(reload_object(logical_volume))
def test_adds_partition_by_name(self):
node = factory.make_Node()
volume_group = factory.make_VolumeGroup(node=node)
block_device = factory.make_PhysicalBlockDevice(node=node)
partition_table = factory.make_PartitionTable(
block_device=block_device)
partition = factory.make_Partition(partition_table=partition_table)
data = {"add_partitions": [partition.name]}
form = UpdateVolumeGroupForm(volume_group, data=data)
self.assertTrue(form.is_valid(), form._errors)
volume_group = form.save()
self.assertEqual(
volume_group.id,
partition.get_effective_filesystem().filesystem_group.id,
)
def test_is_not_valid_if_size_less_than_minimum_block_size(self):
volume_group = factory.make_VolumeGroup()
name = factory.make_name("lv")
data = {"name": name, "size": MIN_BLOCK_DEVICE_SIZE - 1}
form = CreateLogicalVolumeForm(volume_group, data=data)
self.assertFalse(form.is_valid(),
"Should be invalid because of an invalid size.")
self.assertEqual(
{
"size": [
"Ensure this value is greater than or equal to %s." %
MIN_BLOCK_DEVICE_SIZE
]
},
form._errors,
)
def test_get_parents_handles_cache_set(self):
# Regression test for lp1519397
node = factory.make_Node(with_boot_disk=False)
volume_group = factory.make_VolumeGroup(node=node)
name = factory.make_name()
vguuid = "%s" % uuid4()
size = random.randint(MIN_BLOCK_DEVICE_SIZE, volume_group.get_size())
logical_volume = volume_group.create_logical_volume(name=name,
uuid=vguuid,
size=size)
logical_volume = reload_object(logical_volume)
sdb = factory.make_PhysicalBlockDevice(node=node)
factory.make_CacheSet(block_device=sdb, node=node)
self.assertItemsEqual(
[fs.block_device_id for fs in volume_group.filesystems.all()],
[parent.id for parent in logical_volume.get_parents()])
def test_removes_partition(self):
node = factory.make_Node()
volume_group = factory.make_VolumeGroup(node=node)
block_device = factory.make_PhysicalBlockDevice(node=node)
partition_table = factory.make_PartitionTable(
block_device=block_device)
partition = factory.make_Partition(partition_table=partition_table)
factory.make_Filesystem(fstype=FILESYSTEM_TYPE.LVM_PV,
partition=partition,
filesystem_group=volume_group)
data = {
'remove_partitions': [partition.id],
}
form = UpdateVolumeGroupForm(volume_group, data=data)
self.assertTrue(form.is_valid(), form._errors)
volume_group = form.save()
self.assertIsNone(partition.get_effective_filesystem())
def test_creates_logical_volume(self):
volume_group = factory.make_VolumeGroup()
name = factory.make_name("lv")
vguuid = "%s" % uuid.uuid4()
size = random.randint(MIN_BLOCK_DEVICE_SIZE, volume_group.get_size())
data = {"name": name, "uuid": vguuid, "size": size}
form = CreateLogicalVolumeForm(volume_group, data=data)
self.assertTrue(form.is_valid(), form._errors)
logical_volume = form.save()
expected_size = round_size_to_nearest_block(
size, PARTITION_ALIGNMENT_SIZE, False
)
self.assertThat(
logical_volume,
MatchesStructure.byEquality(
name=name, uuid=vguuid, size=expected_size
),
)
def test_is_not_valid_if_free_space_less_than_min_size(self):
volume_group = factory.make_VolumeGroup()
volume_group.create_logical_volume(factory.make_name("lv"),
size=volume_group.get_size())
name = factory.make_name("lv")
data = {"name": name, "size": MIN_BLOCK_DEVICE_SIZE}
form = CreateLogicalVolumeForm(volume_group, data=data)
self.assertFalse(form.is_valid(),
"Should be invalid because of an no free space.")
self.assertEqual(
{
"__all__": [
"Volume group (%s) cannot hold any more logical volumes, "
"because it doesn't have enough free space." %
(volume_group.name)
]
},
form._errors,
)
def test_is_not_valid_if_size_greater_than_free_space(self):
volume_group = factory.make_VolumeGroup()
volume_group.create_logical_volume(factory.make_name("lv"),
size=volume_group.get_size() -
MIN_BLOCK_DEVICE_SIZE - 1)
name = factory.make_name("lv")
free_space = volume_group.get_lvm_free_space()
data = {
'name': name,
'size': free_space + 2,
}
form = CreateLogicalVolumeForm(volume_group, data=data)
self.assertFalse(form.is_valid(),
"Should be invalid because of an invalid size.")
self.assertEqual(
{
'size': [
"Ensure this value is less than or equal to %s." %
(volume_group.get_lvm_free_space()),
]
}, form._errors)
def test_requires_no_fields(self):
volume_group = factory.make_VolumeGroup()
form = CreateLogicalVolumeForm(volume_group, data={})
self.assertFalse(form.is_valid(), form.errors)
self.assertItemsEqual(['name', 'size'], form.errors.keys())
def test_requires_no_fields(self):
volume_group = factory.make_VolumeGroup()
form = UpdateVolumeGroupForm(volume_group, data={})
self.assertTrue(form.is_valid(), form.errors)
