def test_delete_not_allowed_if_part_of_filesystem_group(self): partition = factory.make_Partition(size=1024**3, block_device_size=2 * 1024**3) VolumeGroup.objects.create_volume_group(factory.make_name("vg"), [], [partition]) error = self.assertRaises(ValidationError, partition.delete) self.assertEqual( "Cannot delete partition because its part of a volume group.", error.message)
def make_partition(self, node): device = factory.make_PhysicalBlockDevice( node=node, size=(MIN_PARTITION_SIZE * 4) + PARTITION_TABLE_EXTRA_SPACE, ) partition_table = factory.make_PartitionTable(block_device=device) return factory.make_Partition( partition_table=partition_table, size=MIN_PARTITION_SIZE )
def test_get_effective_filesystem(self): mock_get_effective_filesystem = self.patch_autospec( partition_module, "get_effective_filesystem" ) mock_get_effective_filesystem.return_value = sentinel.filesystem partition = factory.make_Partition() self.assertEqual( sentinel.filesystem, partition.get_effective_filesystem() )
def test_remove_invalid_spare_partition_fails(self): raid = _make_interesting_RAID(node=factory.make_Node()) ids = [factory.make_Partition().id for _ in range(2)] form = UpdateRaidForm(raid, data={'remove_spare_partitions': ids}) self.assertFalse(form.is_valid(), form.errors) self.assertIn('remove_spare_partitions', form.errors) self.assertIn( 'is not one of the available choices.', form.errors['remove_spare_partitions'][0])
def test_add_valid_partition(self): raid = factory.make_FilesystemGroup( group_type=FILESYSTEM_GROUP_TYPE.RAID_6) # Add 5 new partitions to the node. part_ids = [ factory.make_Partition(node=raid.get_node()).id for _ in range(5) ] form = UpdateRaidForm(raid, data={"add_partitions": part_ids}) self.assertTrue(form.is_valid(), form.errors)
def test_get_partition_by_id_or_name_invalid_part_seperator(self): partition = factory.make_Partition() self.assertRaises( Partition.DoesNotExist, Partition.objects.get_partition_by_id_or_name, "%spart%s" % ( partition.partition_table.block_device.get_name(), partition.get_partition_number() ))
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_get_partition_by_id_or_name_by_name_invalid_table(self): partition_table = factory.make_PartitionTable() other_table = factory.make_PartitionTable() partition = factory.make_Partition(partition_table=partition_table) self.assertRaises( Partition.DoesNotExist, Partition.objects.get_partition_by_id_or_name, partition.name, other_table, )
def test_add_invalid_spare_partition_fails(self): raid = factory.make_FilesystemGroup( group_type=FILESYSTEM_GROUP_TYPE.RAID_6) # Add 5 new partitions to other nodes. part_ids = [factory.make_Partition().id for _ in range(5)] form = UpdateRaidForm(raid, data={'add_spare_partitions': part_ids}) self.assertFalse(form.is_valid(), form.errors) self.assertIn('add_spare_partitions', form.errors) self.assertIn('is not one of the available choices.', form.errors['add_spare_partitions'][0])
def test_is_not_valid_if_invalid_uuid(self): fstype = factory.pick_filesystem_type() partition = factory.make_Partition() data = { 'fstype': fstype, 'uuid': factory.make_string(size=32), } form = FormatPartitionForm(partition, 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_save_updates_the_cache_set_with_partition(self): node = factory.make_Node() cache_device = factory.make_PhysicalBlockDevice(node=node) cache_set = factory.make_CacheSet(block_device=cache_device) new_partition = factory.make_Partition(node=node) form = UpdateCacheSetForm(cache_set=cache_set, data={"cache_partition": new_partition.id}) self.assertTrue(form.is_valid(), form.errors) cache_set = form.save() self.assertEqual(new_partition, cache_set.get_device()) self.assertIsNone(cache_device.get_effective_filesystem())
def test_save_updates_the_cache_set_with_boot_disk(self): node = factory.make_Node(with_boot_disk=False) boot_disk = factory.make_PhysicalBlockDevice(node=node) partition = factory.make_Partition(node=node) cache_set = factory.make_CacheSet(partition=partition) form = UpdateCacheSetForm(cache_set=cache_set, data={"cache_device": boot_disk.id}) self.assertTrue(form.is_valid(), form.errors) cache_set = form.save() boot_partition = boot_disk.get_partitiontable().partitions.first() self.assertEqual(boot_partition, cache_set.get_device()) self.assertIsNone(partition.get_effective_filesystem())
def test_cache_set_creation_with_partition(self): node = factory.make_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) form = CreateCacheSetForm(node=node, data={"cache_partition": partition.id}) self.assertTrue(form.is_valid(), form.errors) cache_set = form.save() self.assertEqual(partition, cache_set.get_device())
def test_creates_filesystem(self): fsuuid = "%s" % uuid.uuid4() fstype = factory.pick_filesystem_type() partition = factory.make_Partition() data = {"uuid": fsuuid, "fstype": fstype} form = FormatPartitionForm(partition, data=data) self.assertTrue(form.is_valid(), form._errors) form.save() filesystem = get_one(Filesystem.objects.filter(partition=partition)) self.assertIsNotNone(filesystem) self.assertEqual(fstype, filesystem.fstype) self.assertEqual(fsuuid, filesystem.uuid)
def test_max_possible_size_if_not_specified(self): block_device = factory.make_PhysicalBlockDevice() partition_table = factory.make_PartitionTable( block_device=block_device) first_partition = factory.make_Partition( partition_table=partition_table, size=10 * 1024 * 1024) data = {"uuid": str(uuid.uuid4())} form = AddPartitionForm(block_device, data=data) self.assertTrue(form.is_valid(), form.errors) partition = form.save() self.assertEqual(partition.size, partition_table.get_size() - first_partition.size)
def test_list_partitions(self): device = factory.make_PhysicalBlockDevice( size=(MIN_PARTITION_SIZE * 4) + PARTITION_TABLE_EXTRA_SPACE) partition_table = factory.make_PartitionTable(block_device=device) partition1 = factory.make_Partition(partition_table=partition_table, size=MIN_PARTITION_SIZE) partition2 = factory.make_Partition(partition_table=partition_table, size=MIN_PARTITION_SIZE) uri = get_partitions_uri(device) response = self.client.get(uri) self.assertEqual(http.client.OK, response.status_code, response.content) partitions = json.loads( response.content.decode(settings.DEFAULT_CHARSET)) p1 = [p for p in partitions if p["id"] == partition1.id][0] p2 = [p for p in partitions if p["id"] == partition2.id][0] self.assertEqual(partition1.size, p1["size"]) self.assertEqual(partition1.uuid, p1["uuid"]) self.assertEqual(partition2.size, p2["size"]) self.assertEqual(partition2.uuid, p2["uuid"])
def test_adds_partition_by_name(self): node = make_Node_with_VMFS6_layout() vmfs = factory.make_VMFS(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 = UpdateVMFSForm(vmfs, data=data) self.assertTrue(form.is_valid(), form._errors) vmfs = form.save() self.assertEqual( vmfs.id, partition.get_effective_filesystem().filesystem_group.id)
def test_get_physical_block_device_raid_on_part(self): # Regression test for LP:1849580 node = factory.make_Node(with_boot_disk=False) block_devices = [] partitions = [] for _ in range(2): block_device = factory.make_PhysicalBlockDevice(node=node) block_devices.append(block_device) pt = factory.make_PartitionTable(block_device=block_device) partitions.append(factory.make_Partition(partition_table=pt)) fs_group = RAID.objects.create_raid( level=FILESYSTEM_GROUP_TYPE.RAID_1, partitions=partitions ) fs = factory.make_Filesystem(block_device=fs_group.virtual_device) self.assertItemsEqual(fs.get_physical_block_devices(), block_devices)
def test_will_not_unmount_filesystem_on_partition(self): node = factory.make_Node() partition = factory.make_Partition(node=node) filesystem = factory.make_Filesystem( mount_point=factory.make_absolute_path(), partition=partition) form = UnmountNonStorageFilesystemForm( node, data={"mount_point": filesystem.mount_point}) self.assertFalse(form.is_valid()) self.assertThat( form.errors, Equals({ "mount_point": ["No special filesystem is mounted at this path."] }), )
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_adds_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) data = {"add_partitions": [partition.id]} 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_invalid_format_fstype(self): partition = factory.make_Partition() data = {"fstype": FILESYSTEM_TYPE.LVM_PV} form = FormatPartitionForm(partition, data=data) self.assertFalse(form.is_valid(), "Should be invalid because of an invalid fstype.") self.assertEqual( { "fstype": [ "Select a valid choice. lvm-pv is not one of the " "available choices." ] }, form._errors, )
def test_get_partitions_in_filesystem_group(self): node = factory.make_Node() filesystem_group = factory.make_FilesystemGroup( group_type=FILESYSTEM_GROUP_TYPE.LVM_VG) block_device_with_partitions = factory.make_PhysicalBlockDevice( node=node) partition_table = factory.make_PartitionTable( block_device=block_device_with_partitions) partition = factory.make_Partition(partition_table=partition_table) factory.make_Filesystem(fstype=FILESYSTEM_TYPE.LVM_PV, partition=partition, filesystem_group=filesystem_group) partitions_in_filesystem_group = ( Partition.objects.get_partitions_in_filesystem_group( filesystem_group)) self.assertItemsEqual([partition], partitions_in_filesystem_group)
def test_deletes_old_filesystem_and_creates_new_one(self): fstype = factory.pick_filesystem_type() partition = factory.make_Partition() prev_filesystem = factory.make_Filesystem(partition=partition) data = {"fstype": fstype} form = FormatPartitionForm(partition, data=data) self.assertTrue(form.is_valid(), form._errors) form.save() self.assertEqual( 1, Filesystem.objects.filter(partition=partition).count(), "Should only be one filesystem that exists for partition.", ) self.assertIsNone(reload_object(prev_filesystem)) filesystem = get_one(Filesystem.objects.filter(partition=partition)) self.assertIsNotNone(filesystem) self.assertEqual(fstype, filesystem.fstype)
def test_filter_by_node(self): node = factory.make_Node() boot_bd = node.blockdevice_set.first() root_partition = boot_bd.partitiontable_set.first().partitions.first() root_fs = root_partition.filesystem_set.first() block_device = factory.make_PhysicalBlockDevice(node=node) bd_for_partitions = factory.make_PhysicalBlockDevice(node=node) partition_table = factory.make_PartitionTable( block_device=bd_for_partitions) partition = factory.make_Partition(partition_table=partition_table) filesystem_on_bd = factory.make_Filesystem(block_device=block_device) filesystem_on_partition = factory.make_Filesystem(partition=partition) filesystem_on_node = factory.make_Filesystem(node=node) self.assertItemsEqual([ root_fs, filesystem_on_bd, filesystem_on_partition, filesystem_on_node ], Filesystem.objects.filter_by_node(node))
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_is_not_valid_if_partition_does_not_belong_to_node(self): node = make_Node_with_VMFS6_layout() partition = factory.make_Partition() data = { 'name': factory.make_name('name'), 'partitions': [partition.id], } form = CreateVMFSForm(node, data=data) self.assertFalse( form.is_valid(), 'Should be invalid because of partition does not ' 'belonging to node.') self.assertEqual({ 'partitions': [ 'Select a valid choice. %s is not one of the available ' 'choices.' % partition.id, ]}, form._errors)
def test_removes_partition_by_name(self): node = make_Node_with_VMFS6_layout() vmfs = factory.make_VMFS(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=vmfs) data = { 'remove_partitions': [partition.name], } form = UpdateVMFSForm(vmfs, data=data) self.assertTrue(form.is_valid(), form._errors) vmfs = form.save() self.assertIsNone(partition.get_effective_filesystem())
def test_read_partition_by_name(self): device = factory.make_PhysicalBlockDevice( size=(MIN_PARTITION_SIZE * 4) + PARTITION_TABLE_EXTRA_SPACE) partition_table = factory.make_PartitionTable(block_device=device) partition = factory.make_Partition( partition_table=partition_table, size=MIN_PARTITION_SIZE, bootable=True) uri = get_partition_uri(partition, by_name=True) response = self.client.get(uri) self.assertEqual( http.client.OK, response.status_code, response.content) parsed_partition = json.loads( response.content.decode(settings.DEFAULT_CHARSET)) self.assertTrue(parsed_partition['bootable']) self.assertEqual(partition.id, parsed_partition['id']) self.assertEqual(partition.size, parsed_partition['size'])
def test_is_not_valid_if_partition_does_not_belong_to_node(self): node = factory.make_Node() partition = factory.make_Partition() data = { 'name': factory.make_name("name"), 'partitions': [partition.id], } form = CreateVolumeGroupForm(node, data=data) self.assertFalse( form.is_valid(), "Should be invalid because of partition does not " "belonging to node.") self.assertEqual( { 'partitions': [ "Select a valid choice. %s is not one of the available " "choices." % partition.id, ] }, form._errors)