def test_single_disk_with_vg_reverse_order(self):
start_data = [{'id': 'home',
'type': 'vg',
'volumes': [{'file_system': 'ext3',
'mount': '/home',
'name': 'home',
'size': "100%",
'type': 'lv'}]},
{'id': {'type': 'name', 'value': 'vda'},
'size': 10000,
'type': 'disk',
'volumes': [{'size': '50%', 'type': 'partition'},
{'size': '49%', 'type': 'pv',
'vg': 'home'}]}]
desired = [{'id': {'type': 'name', 'value': 'vda'},
'size': 10000,
'type': 'disk',
'volumes': [{'size': 5000, 'type': 'partition'},
{'size': 4900, 'type': 'pv',
'vg': 'home'}]},
{'id': 'home',
'type': 'vg',
'volumes': [{'file_system': 'ext3',
'mount': '/home',
'name': 'home',
'size': 4900 - self.LVM,
'type': 'lv'}]}]
result = ironic._resolve_all_sizes(start_data)
map(lambda r, d: self.assertDictEqual(r, d), result, desired)
def test_single_disk_percent_unicode(self):
start_data = [
{'id': {'type': 'name', 'value': 'vda'}, 'size': 10000,
'type': 'disk', 'volumes': [{'size': u'50%', 'type': 'partition'},
{'size': 4900,
'type': 'partition'}]}]
desired = [
{'id': {'type': 'name', 'value': 'vda'}, 'size': 10000,
'type': 'disk', 'volumes': [{'size': 5000, 'type': 'partition'},
{'size': 4900,
'type': 'partition'}]}]
result = ironic._resolve_all_sizes(start_data)
map(lambda r, d: self.assertDictEqual(r, d), result, desired)
def test_single_disk_remaining(self):
start_data = [
{'id': {'type': 'name', 'value': 'vda'}, 'size': 10000,
'type': 'disk',
'volumes': [{'size': '50%', 'type': 'partition', 'mount': '/'},
{'size': 'remaining', 'type': 'partition',
'mount': '/home'}]}]
desired = [
{'id': {'type': 'name', 'value': 'vda'}, 'size': 10000,
'type': 'disk',
'volumes': [{'size': 5000, 'type': 'partition', 'mount': '/'},
{'size': 5000 - self.GRUB, 'type': 'partition',
'mount': '/home'}]}]
result = ironic._resolve_all_sizes(start_data)
map(lambda r, d: self.assertDictEqual(r, d), result, desired)
def test_single_disk_with_pv_and_lv_remaining(self):
disk_size = 10000
start_data = [{'id': {'type': 'name', 'value': 'vda'},
'size': disk_size,
'type': 'disk',
'volumes': [{'mount': '/',
'size': '50%',
'type': 'partition'},
{'size': 'remaining',
'type': 'pv',
'vg': 'home'}]},
{'id': 'home',
'type': 'vg',
'volumes': [{'mount': '/var',
'size': 'remaining',
'type': 'lv'},
{'mount': '/home',
'size': '30%',
'type': 'lv'}]}]
expected_partition_size = disk_size * 0.50
expected_home_pv_size = (disk_size - expected_partition_size -
ironic.DEFAULT_GRUB_SIZE)
expected_home_lv_size = int((expected_home_pv_size -
ironic.DEFAULT_LVM_META_SIZE) * 0.3)
expected_var_lv_size = (expected_home_pv_size - expected_home_lv_size -
ironic.DEFAULT_LVM_META_SIZE)
desired = [{'id': {'type': 'name', 'value': 'vda'},
'size': disk_size,
'type': 'disk',
'volumes': [{'mount': '/',
'size': expected_partition_size,
'type': 'partition'},
{'size': expected_home_pv_size,
'type': 'pv',
'vg': 'home'}]},
{'id': 'home',
'type': 'vg',
'volumes': [{'mount': '/var',
'size': expected_var_lv_size,
'type': 'lv'},
{'mount': '/home',
'size': expected_home_lv_size,
'type': 'lv'}]}]
result = ironic._resolve_all_sizes(start_data)
map(lambda r, d: self.assertDictEqual(r, d), result, desired)
def test_single_disk_remaining(self):
start_data = [{
'id': {
'type': 'name',
'value': 'vda'
},
'size':
10000,
'type':
'disk',
'volumes': [{
'size': '50%',
'type': 'partition',
'mount': '/'
}, {
'size': 'remaining',
'type': 'partition',
'mount': '/home'
}]
}]
desired = [{
'id': {
'type': 'name',
'value': 'vda'
},
'size':
10000,
'type':
'disk',
'volumes': [{
'size': 5000,
'type': 'partition',
'mount': '/'
}, {
'size': 5000 - self.GRUB,
'type': 'partition',
'mount': '/home'
}]
}]
result = ironic._resolve_all_sizes(start_data)
map(lambda r, d: self.assertDictEqual(r, d), result, desired)
def test_single_disk_with_lv_remaining(self):
start_data = [{'id': {'type': 'name', 'value': 'vda'},
'size': 10000,
'type': 'disk',
'volumes': [{'mount': '/',
'size': '50%',
'type': 'partition'},
{'size': '49%',
'type': 'pv',
'vg': 'home'}]},
{'id': 'home',
'type': 'vg',
'volumes': [{'mount': '/var',
'size': 'remaining',
'type': 'lv'},
{'mount': '/home',
'size': '30%',
'type': 'lv'}]}]
desired = [{'id': {'type': 'name', 'value': 'vda'},
'size': 10000,
'type': 'disk',
'volumes': [{'mount': '/',
'size': 5000,
'type': 'partition'},
{'size': 4900,
'type': 'pv',
'vg': 'home'}]},
{'id': 'home',
'type': 'vg',
'volumes': [{'mount': '/var',
'size': 4836 - (int(0.3 * 4836)),
'type': 'lv'},
{'mount': '/home',
'size': int(0.3 * 4836),
'type': 'lv'}]}]
result = ironic._resolve_all_sizes(start_data)
map(lambda r, d: self.assertDictEqual(r, d), result, desired)
def test_single_disk_percent_unicode(self):
start_data = [{
'id': {
'type': 'name',
'value': 'vda'
},
'size':
10000,
'type':
'disk',
'volumes': [{
'size': u'50%',
'type': 'partition'
}, {
'size': 4900,
'type': 'partition'
}]
}]
desired = [{
'id': {
'type': 'name',
'value': 'vda'
},
'size':
10000,
'type':
'disk',
'volumes': [{
'size': 5000,
'type': 'partition'
}, {
'size': 4900,
'type': 'partition'
}]
}]
result = ironic._resolve_all_sizes(start_data)
map(lambda r, d: self.assertDictEqual(r, d), result, desired)
def test_single_disk_with_vg_lvm_meta_size(self):
start_data = [{
'id': {
'type': 'name',
'value': 'vda'
},
'size':
10000,
'type':
'disk',
'volumes': [{
'size': '50%',
'type': 'partition'
}, {
'size': '49%',
'type': 'pv',
'vg': 'home',
'lvm_meta_size': 49
}]
}, {
'id':
'home',
'type':
'vg',
'volumes': [{
'file_system': 'ext3',
'mount': '/home',
'name': 'home',
'size': "100%",
'type': 'lv'
}]
}]
desired = [{
'id': {
'type': 'name',
'value': 'vda'
},
'size':
10000,
'type':
'disk',
'volumes': [{
'size': 5000,
'type': 'partition'
}, {
'size': 4900,
'type': 'pv',
'vg': 'home',
'lvm_meta_size': 49
}]
}, {
'id':
'home',
'type':
'vg',
'volumes': [{
'file_system': 'ext3',
'mount': '/home',
'name': 'home',
'size': 4900 - 49,
'type': 'lv'
}]
}]
result = ironic._resolve_all_sizes(start_data)
map(lambda r, d: self.assertDictEqual(r, d), result, desired)
def test_single_disk_with_vg_multiple_pv(self):
start_data = [{
'id': {
'type': 'name',
'value': 'vda'
},
'size': 10000,
'type': 'disk',
'volumes': [{
'size': 7000,
'type': 'pv',
'vg': 'home'
}]
}, {
'id': {
'type': 'name',
'value': 'vdb'
},
'size': 5000,
'type': 'disk',
'volumes': [{
'size': 4000,
'type': 'pv',
'vg': 'home'
}]
}, {
'id':
'home',
'type':
'vg',
'volumes': [{
'file_system': 'ext3',
'mount': '/home',
'name': 'home',
'size': '50%',
'type': 'lv'
}]
}]
desired = [{
'id': {
'type': 'name',
'value': 'vda'
},
'size': 10000,
'type': 'disk',
'volumes': [{
'size': 7000,
'type': 'pv',
'vg': 'home'
}]
}, {
'id': {
'type': 'name',
'value': 'vdb'
},
'size': 5000,
'type': 'disk',
'volumes': [{
'size': 4000,
'type': 'pv',
'vg': 'home'
}]
}, {
'id':
'home',
'type':
'vg',
'volumes': [{
'file_system': 'ext3',
'mount': '/home',
'name': 'home',
'size': 5500 - self.LVM,
'type': 'lv'
}]
}]
result = ironic._resolve_all_sizes(start_data)
map(lambda r, d: self.assertDictEqual(r, d), result, desired)
def test_single_disk_with_pv_and_lv_remaining(self):
disk_size = 10000
start_data = [{
'id': {
'type': 'name',
'value': 'vda'
},
'size':
disk_size,
'type':
'disk',
'volumes': [{
'mount': '/',
'size': '50%',
'type': 'partition'
}, {
'size': 'remaining',
'type': 'pv',
'vg': 'home'
}]
}, {
'id':
'home',
'type':
'vg',
'volumes': [{
'mount': '/var',
'size': 'remaining',
'type': 'lv'
}, {
'mount': '/home',
'size': '30%',
'type': 'lv'
}]
}]
expected_partition_size = disk_size * 0.50
expected_home_pv_size = (disk_size - expected_partition_size -
ironic.DEFAULT_GRUB_SIZE)
expected_home_lv_size = int(
(expected_home_pv_size - ironic.DEFAULT_LVM_META_SIZE) * 0.3)
expected_var_lv_size = (expected_home_pv_size - expected_home_lv_size -
ironic.DEFAULT_LVM_META_SIZE)
desired = [{
'id': {
'type': 'name',
'value': 'vda'
},
'size':
disk_size,
'type':
'disk',
'volumes': [{
'mount': '/',
'size': expected_partition_size,
'type': 'partition'
}, {
'size': expected_home_pv_size,
'type': 'pv',
'vg': 'home'
}]
}, {
'id':
'home',
'type':
'vg',
'volumes': [{
'mount': '/var',
'size': expected_var_lv_size,
'type': 'lv'
}, {
'mount': '/home',
'size': expected_home_lv_size,
'type': 'lv'
}]
}]
result = ironic._resolve_all_sizes(start_data)
map(lambda r, d: self.assertDictEqual(r, d), result, desired)
def test_single_disk_with_lv_remaining(self):
start_data = [{
'id': {
'type': 'name',
'value': 'vda'
},
'size':
10000,
'type':
'disk',
'volumes': [{
'mount': '/',
'size': '50%',
'type': 'partition'
}, {
'size': '49%',
'type': 'pv',
'vg': 'home'
}]
}, {
'id':
'home',
'type':
'vg',
'volumes': [{
'mount': '/var',
'size': 'remaining',
'type': 'lv'
}, {
'mount': '/home',
'size': '30%',
'type': 'lv'
}]
}]
desired = [{
'id': {
'type': 'name',
'value': 'vda'
},
'size':
10000,
'type':
'disk',
'volumes': [{
'mount': '/',
'size': 5000,
'type': 'partition'
}, {
'size': 4900,
'type': 'pv',
'vg': 'home'
}]
}, {
'id':
'home',
'type':
'vg',
'volumes': [{
'mount': '/var',
'size': 4836 - (int(0.3 * 4836)),
'type': 'lv'
}, {
'mount': '/home',
'size': int(0.3 * 4836),
'type': 'lv'
}]
}]
result = ironic._resolve_all_sizes(start_data)
map(lambda r, d: self.assertDictEqual(r, d), result, desired)
