def test_get_disk_mapping_updates_original(self):
instance_ref = objects.Instance(**self.test_instance)
image_meta = {}
block_device_info = {
'root_device_name':
'/dev/vda',
'swap': {
'device_name': '/dev/vdb',
'device_type': 'really_lame_type',
'swap_size': 10
},
'ephemerals': [{
'disk_bus': 'no_such_bus',
'device_type': 'yeah_right',
'device_name': '/dev/vdc',
'size': 10
}],
'block_device_mapping': [{
'connection_info': "fake",
'mount_device': None,
'device_type': 'lawnmower',
'delete_on_termination': True
}]
}
expected_swap = {
'device_name': '/dev/vdb',
'disk_bus': 'virtio',
'device_type': 'disk',
'swap_size': 10
}
expected_ephemeral = {
'disk_bus': 'virtio',
'device_type': 'disk',
'device_name': '/dev/vdc',
'size': 10
}
expected_bdm = {
'connection_info': "fake",
'mount_device': '/dev/vdd',
'device_type': 'disk',
'disk_bus': 'virtio',
'delete_on_termination': True
}
blockinfo.get_disk_mapping("kvm", instance_ref, "virtio", "ide",
image_meta, block_device_info)
self.assertEqual(expected_swap, block_device_info['swap'])
self.assertEqual(expected_ephemeral,
block_device_info['ephemerals'][0])
self.assertEqual(expected_bdm,
block_device_info['block_device_mapping'][0])
def test_get_disk_mapping_simple(self):
# The simplest possible disk mapping setup, all defaults
instance_ref = objects.Instance(**self.test_instance)
image_meta = {}
mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio",
"ide", image_meta)
expect = {
'disk': {
'bus': 'virtio',
'dev': 'vda',
'type': 'disk',
'boot_index': '1'
},
'disk.local': {
'bus': 'virtio',
'dev': 'vdb',
'type': 'disk'
},
'root': {
'bus': 'virtio',
'dev': 'vda',
'type': 'disk',
'boot_index': '1'
}
}
self.assertEqual(expect, mapping)
def test_get_disk_mapping_rescue(self):
# A simple disk mapping setup, but in rescue mode
instance_ref = objects.Instance(**self.test_instance)
image_meta = {}
mapping = blockinfo.get_disk_mapping("kvm",
instance_ref,
"virtio",
"ide",
image_meta,
rescue=True)
expect = {
'disk.rescue': {
'bus': 'virtio',
'dev': 'vda',
'type': 'disk',
'boot_index': '1'
},
'disk': {
'bus': 'virtio',
'dev': 'vdb',
'type': 'disk'
},
'root': {
'bus': 'virtio',
'dev': 'vda',
'type': 'disk',
'boot_index': '1'
},
}
self.assertEqual(expect, mapping)
def test_get_disk_mapping_simple_iso(self):
# A simple disk mapping setup, but with a ISO for root device
instance_ref = objects.Instance(**self.test_instance)
image_meta = {'disk_format': 'iso'}
mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio",
"ide", image_meta)
expect = {
'disk': {
'bus': 'ide',
'dev': 'hda',
'type': 'cdrom',
'boot_index': '1'
},
'disk.local': {
'bus': 'virtio',
'dev': 'vda',
'type': 'disk'
},
'root': {
'bus': 'ide',
'dev': 'hda',
'type': 'cdrom',
'boot_index': '1'
},
}
self.assertEqual(expect, mapping)
def test_get_disk_mapping_simple_swap(self):
# A simple disk mapping setup, but with a swap device added
instance_ref = objects.Instance(**self.test_instance)
instance_ref.flavor.swap = 5
image_meta = {}
mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio",
"ide", image_meta)
expect = {
'disk': {
'bus': 'virtio',
'dev': 'vda',
'type': 'disk',
'boot_index': '1'
},
'disk.local': {
'bus': 'virtio',
'dev': 'vdb',
'type': 'disk'
},
'disk.swap': {
'bus': 'virtio',
'dev': 'vdc',
'type': 'disk'
},
'root': {
'bus': 'virtio',
'dev': 'vda',
'type': 'disk',
'boot_index': '1'
},
}
self.assertEqual(expect, mapping)
def test_get_disk_mapping_blockdev_eph(self):
# A disk mapping with a blockdev replacing the ephemeral device
instance_ref = objects.Instance(**self.test_instance)
image_meta = {}
block_device_info = {
'block_device_mapping': [
{'connection_info': "fake",
'mount_device': "/dev/vdb",
'boot_index': -1,
'delete_on_termination': True},
]
}
mapping = blockinfo.get_disk_mapping("kvm", instance_ref,
"virtio", "ide",
image_meta,
block_device_info)
expect = {
'disk': {'bus': 'virtio', 'dev': 'vda',
'type': 'disk', 'boot_index': '1'},
'/dev/vdb': {'bus': 'virtio', 'dev': 'vdb', 'type': 'disk'},
'root': {'bus': 'virtio', 'dev': 'vda',
'type': 'disk', 'boot_index': '1'},
}
self.assertEqual(expect, mapping)
def test_get_disk_mapping_cdrom_configdrive(self):
# A simple disk mapping setup, with configdrive added as cdrom
# It's necessary to check if the architecture is power, because
# power doesn't have support to ide, and so libvirt translate
# all ide calls to scsi
self.flags(force_config_drive=True)
self.flags(config_drive_format='iso9660')
instance_ref = objects.Instance(**self.test_instance)
image_meta = {}
mapping = blockinfo.get_disk_mapping("kvm", instance_ref,
"virtio", "ide",
image_meta)
bus_ppc = ("scsi", "sdz")
expect_bus = {"ppc": bus_ppc, "ppc64": bus_ppc}
bus, dev = expect_bus.get(blockinfo.libvirt_utils.get_arch({}),
("ide", "hdd"))
expect = {
'disk': {'bus': 'virtio', 'dev': 'vda',
'type': 'disk', 'boot_index': '1'},
'disk.local': {'bus': 'virtio', 'dev': 'vdb', 'type': 'disk'},
'disk.config': {'bus': bus, 'dev': dev, 'type': 'cdrom'},
'root': {'bus': 'virtio', 'dev': 'vda',
'type': 'disk', 'boot_index': '1'}
}
self.assertEqual(expect, mapping)
def test_get_disk_mapping_ephemeral(self):
# A disk mapping with ephemeral devices
instance_ref = objects.Instance(**self.test_instance)
instance_ref.flavor.swap = 5
image_meta = {}
block_device_info = {
'ephemerals': [
{'device_type': 'disk', 'guest_format': 'ext4',
'device_name': '/dev/vdb', 'size': 10},
{'disk_bus': 'ide', 'guest_format': None,
'device_name': '/dev/vdc', 'size': 10},
{'device_type': 'floppy',
'device_name': '/dev/vdd', 'size': 10},
]
}
mapping = blockinfo.get_disk_mapping("kvm", instance_ref,
"virtio", "ide",
image_meta,
block_device_info)
expect = {
'disk': {'bus': 'virtio', 'dev': 'vda',
'type': 'disk', 'boot_index': '1'},
'disk.eph0': {'bus': 'virtio', 'dev': 'vdb',
'type': 'disk', 'format': 'ext4'},
'disk.eph1': {'bus': 'ide', 'dev': 'vdc', 'type': 'disk'},
'disk.eph2': {'bus': 'virtio', 'dev': 'vdd', 'type': 'floppy'},
'disk.swap': {'bus': 'virtio', 'dev': 'vde', 'type': 'disk'},
'root': {'bus': 'virtio', 'dev': 'vda',
'type': 'disk', 'boot_index': '1'},
}
self.assertEqual(expect, mapping)
def test_get_disk_mapping_simple_rootdev(self):
# A simple disk mapping setup, but with custom root device name
instance_ref = objects.Instance(**self.test_instance)
image_meta = {}
block_device_info = {'root_device_name': '/dev/sda'}
mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio",
"ide", image_meta,
block_device_info)
expect = {
'disk': {
'bus': 'scsi',
'dev': 'sda',
'type': 'disk',
'boot_index': '1'
},
'disk.local': {
'bus': 'virtio',
'dev': 'vda',
'type': 'disk'
},
'root': {
'bus': 'scsi',
'dev': 'sda',
'type': 'disk',
'boot_index': '1'
}
}
self.assertEqual(expect, mapping)
def test_get_disk_mapping_blockdev_many(self):
# A disk mapping with a blockdev replacing all devices
instance_ref = objects.Instance(**self.test_instance)
image_meta = {}
block_device_info = {
'block_device_mapping': [
{
'connection_info': "fake",
'mount_device': "/dev/vda",
'boot_index': 0,
'disk_bus': 'scsi',
'delete_on_termination': True
},
{
'connection_info': "fake",
'mount_device': "/dev/vdb",
'boot_index': -1,
'delete_on_termination': True
},
{
'connection_info': "fake",
'mount_device': "/dev/vdc",
'boot_index': -1,
'device_type': 'cdrom',
'delete_on_termination': True
},
]
}
mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio",
"ide", image_meta,
block_device_info)
expect = {
'/dev/vda': {
'bus': 'scsi',
'dev': 'vda',
'type': 'disk',
'boot_index': '1'
},
'/dev/vdb': {
'bus': 'virtio',
'dev': 'vdb',
'type': 'disk'
},
'/dev/vdc': {
'bus': 'virtio',
'dev': 'vdc',
'type': 'cdrom'
},
'root': {
'bus': 'scsi',
'dev': 'vda',
'type': 'disk',
'boot_index': '1'
},
}
self.assertEqual(expect, mapping)
def test_get_disk_mapping_updates_original(self):
instance_ref = objects.Instance(**self.test_instance)
image_meta = {}
block_device_info = {
'root_device_name': '/dev/vda',
'swap': {'device_name': '/dev/vdb',
'device_type': 'really_lame_type',
'swap_size': 10},
'ephemerals': [{'disk_bus': 'no_such_bus',
'device_type': 'yeah_right',
'device_name': '/dev/vdc', 'size': 10}],
'block_device_mapping': [
{'connection_info': "fake",
'mount_device': None,
'device_type': 'lawnmower',
'delete_on_termination': True}]
}
expected_swap = {'device_name': '/dev/vdb', 'disk_bus': 'virtio',
'device_type': 'disk', 'swap_size': 10}
expected_ephemeral = {'disk_bus': 'virtio',
'device_type': 'disk',
'device_name': '/dev/vdc', 'size': 10}
expected_bdm = {'connection_info': "fake",
'mount_device': '/dev/vdd',
'device_type': 'disk',
'disk_bus': 'virtio',
'delete_on_termination': True}
blockinfo.get_disk_mapping("kvm", instance_ref,
"virtio", "ide",
image_meta,
block_device_info)
self.assertEqual(expected_swap, block_device_info['swap'])
self.assertEqual(expected_ephemeral,
block_device_info['ephemerals'][0])
self.assertEqual(expected_bdm,
block_device_info['block_device_mapping'][0])
def test_get_disk_mapping_simple_configdrive(self):
# A simple disk mapping setup, but with configdrive added
# It's necessary to check if the architecture is power, because
# power doesn't have support to ide, and so libvirt translate
# all ide calls to scsi
self.flags(force_config_drive=True)
instance_ref = objects.Instance(**self.test_instance)
image_meta = {}
mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio",
"ide", image_meta)
# The last device is selected for this. on x86 is the last ide
# device (hdd). Since power only support scsi, the last device
# is sdz
bus_ppc = ("scsi", "sdz")
expect_bus = {"ppc": bus_ppc, "ppc64": bus_ppc}
bus, dev = expect_bus.get(blockinfo.libvirt_utils.get_arch({}),
("ide", "hdd"))
expect = {
'disk': {
'bus': 'virtio',
'dev': 'vda',
'type': 'disk',
'boot_index': '1'
},
'disk.local': {
'bus': 'virtio',
'dev': 'vdb',
'type': 'disk'
},
'disk.config': {
'bus': bus,
'dev': dev,
'type': 'cdrom'
},
'root': {
'bus': 'virtio',
'dev': 'vda',
'type': 'disk',
'boot_index': '1'
}
}
self.assertEqual(expect, mapping)
def test_get_disk_mapping_lxc(self):
# A simple disk mapping setup, but for lxc
self.test_instance['ephemeral_gb'] = 0
instance_ref = objects.Instance(**self.test_instance)
image_meta = {}
mapping = blockinfo.get_disk_mapping("lxc", instance_ref,
"lxc", "lxc",
image_meta)
expect = {
'disk': {'bus': 'lxc', 'dev': None,
'type': 'disk', 'boot_index': '1'},
'root': {'bus': 'lxc', 'dev': None,
'type': 'disk', 'boot_index': '1'},
}
self.assertEqual(expect, mapping)
def test_get_disk_mapping_simple_iso(self):
# A simple disk mapping setup, but with a ISO for root device
instance_ref = objects.Instance(**self.test_instance)
image_meta = {'disk_format': 'iso'}
mapping = blockinfo.get_disk_mapping("kvm", instance_ref,
"virtio", "ide",
image_meta)
expect = {
'disk': {'bus': 'ide', 'dev': 'hda',
'type': 'cdrom', 'boot_index': '1'},
'disk.local': {'bus': 'virtio', 'dev': 'vda', 'type': 'disk'},
'root': {'bus': 'ide', 'dev': 'hda',
'type': 'cdrom', 'boot_index': '1'},
}
self.assertEqual(expect, mapping)
def test_get_disk_mapping_simple(self):
# The simplest possible disk mapping setup, all defaults
instance_ref = objects.Instance(**self.test_instance)
image_meta = {}
mapping = blockinfo.get_disk_mapping("kvm", instance_ref,
"virtio", "ide",
image_meta)
expect = {
'disk': {'bus': 'virtio', 'dev': 'vda',
'type': 'disk', 'boot_index': '1'},
'disk.local': {'bus': 'virtio', 'dev': 'vdb', 'type': 'disk'},
'root': {'bus': 'virtio', 'dev': 'vda',
'type': 'disk', 'boot_index': '1'}
}
self.assertEqual(expect, mapping)
def test_get_disk_mapping_rescue(self):
# A simple disk mapping setup, but in rescue mode
instance_ref = objects.Instance(**self.test_instance)
image_meta = {}
mapping = blockinfo.get_disk_mapping("kvm", instance_ref,
"virtio", "ide",
image_meta,
rescue=True)
expect = {
'disk.rescue': {'bus': 'virtio', 'dev': 'vda',
'type': 'disk', 'boot_index': '1'},
'disk': {'bus': 'virtio', 'dev': 'vdb', 'type': 'disk'},
'root': {'bus': 'virtio', 'dev': 'vda',
'type': 'disk', 'boot_index': '1'},
}
self.assertEqual(expect, mapping)
def test_get_disk_mapping_simple_swap(self):
# A simple disk mapping setup, but with a swap device added
instance_ref = objects.Instance(**self.test_instance)
instance_ref.flavor.swap = 5
image_meta = {}
mapping = blockinfo.get_disk_mapping("kvm", instance_ref,
"virtio", "ide",
image_meta)
expect = {
'disk': {'bus': 'virtio', 'dev': 'vda',
'type': 'disk', 'boot_index': '1'},
'disk.local': {'bus': 'virtio', 'dev': 'vdb', 'type': 'disk'},
'disk.swap': {'bus': 'virtio', 'dev': 'vdc', 'type': 'disk'},
'root': {'bus': 'virtio', 'dev': 'vda',
'type': 'disk', 'boot_index': '1'},
}
self.assertEqual(expect, mapping)
def test_get_disk_mapping_complex(self):
# The strangest possible disk mapping setup
instance_ref = objects.Instance(**self.test_instance)
image_meta = {}
block_device_info = {
'root_device_name': '/dev/vdf',
'swap': {'device_name': '/dev/vdy',
'swap_size': 10},
'ephemerals': [
{'device_type': 'disk', 'guest_format': 'ext4',
'device_name': '/dev/vdb', 'size': 10},
{'disk_bus': 'ide', 'guest_format': None,
'device_name': '/dev/vdc', 'size': 10},
],
'block_device_mapping': [
{'connection_info': "fake",
'mount_device': "/dev/vda",
'boot_index': 1,
'delete_on_termination': True},
]
}
mapping = blockinfo.get_disk_mapping("kvm", instance_ref,
"virtio", "ide",
image_meta,
block_device_info)
expect = {
'disk': {'bus': 'virtio', 'dev': 'vdf',
'type': 'disk', 'boot_index': '1'},
'/dev/vda': {'bus': 'virtio', 'dev': 'vda',
'type': 'disk', 'boot_index': '2'},
'disk.eph0': {'bus': 'virtio', 'dev': 'vdb',
'type': 'disk', 'format': 'ext4'},
'disk.eph1': {'bus': 'ide', 'dev': 'vdc', 'type': 'disk'},
'disk.swap': {'bus': 'virtio', 'dev': 'vdy', 'type': 'disk'},
'root': {'bus': 'virtio', 'dev': 'vdf',
'type': 'disk', 'boot_index': '1'},
}
self.assertEqual(expect, mapping)
def test_get_disk_mapping_disk_configdrive(self):
# A simple disk mapping setup, with configdrive added as disk
self.flags(force_config_drive=True)
self.flags(config_drive_format='vfat')
instance_ref = objects.Instance(**self.test_instance)
image_meta = {}
mapping = blockinfo.get_disk_mapping("kvm", instance_ref,
"virtio", "ide",
image_meta)
expect = {
'disk': {'bus': 'virtio', 'dev': 'vda',
'type': 'disk', 'boot_index': '1'},
'disk.local': {'bus': 'virtio', 'dev': 'vdb', 'type': 'disk'},
'disk.config': {'bus': 'virtio', 'dev': 'vdz', 'type': 'disk'},
'root': {'bus': 'virtio', 'dev': 'vda',
'type': 'disk', 'boot_index': '1'},
}
self.assertEqual(expect, mapping)
def test_get_disk_mapping_simple_rootdev(self):
# A simple disk mapping setup, but with custom root device name
instance_ref = objects.Instance(**self.test_instance)
image_meta = {}
block_device_info = {
'root_device_name': '/dev/sda'
}
mapping = blockinfo.get_disk_mapping("kvm", instance_ref,
"virtio", "ide",
image_meta,
block_device_info)
expect = {
'disk': {'bus': 'scsi', 'dev': 'sda',
'type': 'disk', 'boot_index': '1'},
'disk.local': {'bus': 'virtio', 'dev': 'vda', 'type': 'disk'},
'root': {'bus': 'scsi', 'dev': 'sda',
'type': 'disk', 'boot_index': '1'}
}
self.assertEqual(expect, mapping)
def test_get_disk_mapping_custom_swap(self):
# A disk mapping with a swap device at position vdb. This
# should cause disk.local to be removed
instance_ref = objects.Instance(**self.test_instance)
image_meta = {}
block_device_info = {
'swap': {'device_name': '/dev/vdb',
'swap_size': 10},
}
mapping = blockinfo.get_disk_mapping("kvm", instance_ref,
"virtio", "ide",
image_meta,
block_device_info)
expect = {
'disk': {'bus': 'virtio', 'dev': 'vda',
'type': 'disk', 'boot_index': '1'},
'disk.swap': {'bus': 'virtio', 'dev': 'vdb', 'type': 'disk'},
'root': {'bus': 'virtio', 'dev': 'vda',
'type': 'disk', 'boot_index': '1'},
}
self.assertEqual(expect, mapping)
def test_get_disk_mapping_disk_configdrive(self):
# A simple disk mapping setup, with configdrive added as disk
self.flags(force_config_drive=True)
self.flags(config_drive_format='vfat')
instance_ref = objects.Instance(**self.test_instance)
image_meta = {}
mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio",
"ide", image_meta)
expect = {
'disk': {
'bus': 'virtio',
'dev': 'vda',
'type': 'disk',
'boot_index': '1'
},
'disk.local': {
'bus': 'virtio',
'dev': 'vdb',
'type': 'disk'
},
'disk.config': {
'bus': 'virtio',
'dev': 'vdz',
'type': 'disk'
},
'root': {
'bus': 'virtio',
'dev': 'vda',
'type': 'disk',
'boot_index': '1'
},
}
self.assertEqual(expect, mapping)
def test_get_disk_mapping_custom_swap(self):
# A disk mapping with a swap device at position vdb. This
# should cause disk.local to be removed
instance_ref = objects.Instance(**self.test_instance)
image_meta = {}
block_device_info = {
'swap': {
'device_name': '/dev/vdb',
'swap_size': 10
},
}
mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio",
"ide", image_meta,
block_device_info)
expect = {
'disk': {
'bus': 'virtio',
'dev': 'vda',
'type': 'disk',
'boot_index': '1'
},
'disk.swap': {
'bus': 'virtio',
'dev': 'vdb',
'type': 'disk'
},
'root': {
'bus': 'virtio',
'dev': 'vda',
'type': 'disk',
'boot_index': '1'
},
}
self.assertEqual(expect, mapping)
def test_get_disk_mapping_lxc(self):
# A simple disk mapping setup, but for lxc
self.test_instance['ephemeral_gb'] = 0
instance_ref = objects.Instance(**self.test_instance)
image_meta = {}
mapping = blockinfo.get_disk_mapping("lxc", instance_ref, "lxc", "lxc",
image_meta)
expect = {
'disk': {
'bus': 'lxc',
'dev': None,
'type': 'disk',
'boot_index': '1'
},
'root': {
'bus': 'lxc',
'dev': None,
'type': 'disk',
'boot_index': '1'
},
}
self.assertEqual(expect, mapping)
def test_get_disk_mapping_complex(self):
# The strangest possible disk mapping setup
instance_ref = objects.Instance(**self.test_instance)
image_meta = {}
block_device_info = {
'root_device_name':
'/dev/vdf',
'swap': {
'device_name': '/dev/vdy',
'swap_size': 10
},
'ephemerals': [
{
'device_type': 'disk',
'guest_format': 'ext4',
'device_name': '/dev/vdb',
'size': 10
},
{
'disk_bus': 'ide',
'guest_format': None,
'device_name': '/dev/vdc',
'size': 10
},
],
'block_device_mapping': [
{
'connection_info': "fake",
'mount_device': "/dev/vda",
'boot_index': 1,
'delete_on_termination': True
},
]
}
mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio",
"ide", image_meta,
block_device_info)
expect = {
'disk': {
'bus': 'virtio',
'dev': 'vdf',
'type': 'disk',
'boot_index': '1'
},
'/dev/vda': {
'bus': 'virtio',
'dev': 'vda',
'type': 'disk',
'boot_index': '2'
},
'disk.eph0': {
'bus': 'virtio',
'dev': 'vdb',
'type': 'disk',
'format': 'ext4'
},
'disk.eph1': {
'bus': 'ide',
'dev': 'vdc',
'type': 'disk'
},
'disk.swap': {
'bus': 'virtio',
'dev': 'vdy',
'type': 'disk'
},
'root': {
'bus': 'virtio',
'dev': 'vdf',
'type': 'disk',
'boot_index': '1'
},
}
self.assertEqual(expect, mapping)
def test_get_disk_mapping_ephemeral(self):
# A disk mapping with ephemeral devices
instance_ref = objects.Instance(**self.test_instance)
instance_ref.flavor.swap = 5
image_meta = {}
block_device_info = {
'ephemerals': [
{
'device_type': 'disk',
'guest_format': 'ext4',
'device_name': '/dev/vdb',
'size': 10
},
{
'disk_bus': 'ide',
'guest_format': None,
'device_name': '/dev/vdc',
'size': 10
},
{
'device_type': 'floppy',
'device_name': '/dev/vdd',
'size': 10
},
]
}
mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio",
"ide", image_meta,
block_device_info)
expect = {
'disk': {
'bus': 'virtio',
'dev': 'vda',
'type': 'disk',
'boot_index': '1'
},
'disk.eph0': {
'bus': 'virtio',
'dev': 'vdb',
'type': 'disk',
'format': 'ext4'
},
'disk.eph1': {
'bus': 'ide',
'dev': 'vdc',
'type': 'disk'
},
'disk.eph2': {
'bus': 'virtio',
'dev': 'vdd',
'type': 'floppy'
},
'disk.swap': {
'bus': 'virtio',
'dev': 'vde',
'type': 'disk'
},
'root': {
'bus': 'virtio',
'dev': 'vda',
'type': 'disk',
'boot_index': '1'
},
}
self.assertEqual(expect, mapping)
