def test_running_start_error():
"""
running state test, start an existing guest raising an error
"""
with patch.dict(virt.__opts__, {"test": False}):
with patch.dict(
virt.__salt__,
{
"virt.vm_state":
MagicMock(return_value={"myvm": "stopped"}),
"virt.update":
MagicMock(return_value={"definition": False}),
"virt.start":
MagicMock(side_effect=[
virt.libvirt.libvirtError("libvirt error msg")
]),
"virt.list_domains":
MagicMock(return_value=["myvm"]),
},
):
assert virt.running("myvm") == {
"name": "myvm",
"changes": {},
"result": False,
"comment": "libvirt error msg",
}
def test_running_no_change(test, running):
"""
running state test, no change required case.
"""
with patch.dict(virt.__opts__, {"test": test}):
update_mock = MagicMock(return_value={"definition": False})
start_mock = MagicMock(return_value=0)
with patch.dict(
virt.__salt__,
{
"virt.vm_state": MagicMock(return_value={"myvm": running}),
"virt.start": start_mock,
"virt.update": MagicMock(return_value={"definition": False}),
"virt.list_domains": MagicMock(return_value=["myvm"]),
},
):
assert virt.running("myvm") == {
"name":
"myvm",
"result":
True,
"changes": {
"myvm": {
"started": True
}
} if running == "shutdown" else {},
"comment":
"Domain myvm started" if running == "shutdown" else
"Domain myvm exists and is running",
}
if running == "shutdown" and not test:
start_mock.assert_called()
else:
start_mock.assert_not_called()
def test_running_update(test, running):
"""
running state test, update an existing guest
"""
with patch.dict(virt.__opts__, {"test": test}):
start_mock = MagicMock(return_value=0)
with patch.dict(
virt.__salt__,
{
"virt.vm_state": MagicMock(return_value={"myvm": running}),
"virt.update": MagicMock(
return_value={"definition": True, "cpu": True}
),
"virt.start": start_mock,
"virt.list_domains": MagicMock(return_value=["myvm"]),
},
):
changes = {"definition": True, "cpu": True}
if running == "shutdown":
changes["started"] = True
assert virt.running("myvm", cpu=2) == {
"name": "myvm",
"changes": {"myvm": changes},
"result": True if not test else None,
"comment": "Domain myvm updated"
if running == "running"
else "Domain myvm updated and started",
}
if running == "shutdown" and not test:
start_mock.assert_called()
else:
start_mock.assert_not_called()
def test_running_update_error():
"""
running state test, update an existing guest raising an error
"""
with patch.dict(virt.__opts__, {"test": False}):
update_mock = MagicMock(return_value={
"definition": True,
"cpu": False,
"errors": ["some error"]
})
with patch.dict(
virt.__salt__,
{
"virt.vm_state": MagicMock(return_value={"myvm": "running"}),
"virt.update": update_mock,
"virt.list_domains": MagicMock(return_value=["myvm"]),
},
):
assert virt.running("myvm", cpu=2) == {
"name": "myvm",
"changes": {
"myvm": {
"definition": True,
"cpu": False,
"errors": ["some error"],
}
},
"result": True,
"comment": "Domain myvm updated with live update(s) failures",
}
update_mock.assert_called_with(
"myvm",
cpu=2,
mem=None,
disk_profile=None,
disks=None,
nic_profile=None,
interfaces=None,
graphics=None,
live=True,
connection=None,
username=None,
password=None,
boot=None,
numatune=None,
test=False,
boot_dev=None,
hypervisor_features=None,
clock=None,
serials=None,
consoles=None,
stop_on_reboot=False,
host_devices=None,
)
def test_running(self):
'''
running state test cases.
'''
ret = {
'name': 'myvm',
'changes': {},
'result': True,
'comment': 'myvm is running'
}
with patch.dict(
virt.__salt__,
{ # pylint: disable=no-member
'virt.vm_state': MagicMock(return_value='stopped'),
'virt.start': MagicMock(return_value=0)
}):
ret.update({
'changes': {
'myvm': 'Domain started'
},
'comment': 'Domain myvm started'
})
self.assertDictEqual(virt.running('myvm'), ret)
with patch.dict(
virt.__salt__,
{ # pylint: disable=no-member
'virt.vm_state':
MagicMock(return_value='stopped'),
'virt.start':
MagicMock(side_effect=[
self.mock_libvirt.libvirtError('libvirt error msg')
])
}):
ret.update({
'changes': {},
'result': False,
'comment': 'libvirt error msg'
})
self.assertDictEqual(virt.running('myvm'), ret)
def test_running_definition_error():
"""
running state test, update an existing guest raising an error when setting the XML
"""
with patch.dict(virt.__opts__, {"test": False}):
with patch.dict(
virt.__salt__,
{
"virt.vm_state": MagicMock(return_value={"myvm": "running"}),
"virt.update": MagicMock(
side_effect=[virt.libvirt.libvirtError("error message")]
),
"virt.list_domains": MagicMock(return_value=["myvm"]),
},
):
assert virt.running("myvm", cpu=3) == {
"name": "myvm",
"changes": {},
"result": False,
"comment": "error message",
}
def test_running(self):
'''
running state test cases.
'''
ret = {'name': 'myvm',
'changes': {},
'result': True,
'comment': 'myvm is running'}
with patch.dict(virt.__salt__, { # pylint: disable=no-member
'virt.vm_state': MagicMock(return_value={'myvm': 'stopped'}),
'virt.start': MagicMock(return_value=0),
}):
ret.update({'changes': {'myvm': 'Domain started'},
'comment': 'Domain myvm started'})
self.assertDictEqual(virt.running('myvm'), ret)
init_mock = MagicMock(return_value=True)
with patch.dict(virt.__salt__, { # pylint: disable=no-member
'virt.vm_state': MagicMock(side_effect=CommandExecutionError('not found')),
'virt.init': init_mock,
'virt.start': MagicMock(return_value=0)
}):
ret.update({'changes': {'myvm': 'Domain defined and started'},
'comment': 'Domain myvm defined and started'})
self.assertDictEqual(virt.running('myvm',
cpu=2,
mem=2048,
image='/path/to/img.qcow2'), ret)
init_mock.assert_called_with('myvm', cpu=2, mem=2048, image='/path/to/img.qcow2',
os_type=None, arch=None,
disk=None, disks=None, nic=None, interfaces=None,
graphics=None, hypervisor=None,
seed=True, install=True, pub_key=None, priv_key=None,
connection=None, username=None, password=None)
with patch.dict(virt.__salt__, { # pylint: disable=no-member
'virt.vm_state': MagicMock(side_effect=CommandExecutionError('not found')),
'virt.init': init_mock,
'virt.start': MagicMock(return_value=0)
}):
ret.update({'changes': {'myvm': 'Domain defined and started'},
'comment': 'Domain myvm defined and started'})
disks = [{
'name': 'system',
'size': 8192,
'overlay_image': True,
'pool': 'default',
'image': '/path/to/image.qcow2'
},
{
'name': 'data',
'size': 16834
}]
ifaces = [{
'name': 'eth0',
'mac': '01:23:45:67:89:AB'
},
{
'name': 'eth1',
'type': 'network',
'source': 'admin'
}]
graphics = {'type': 'spice', 'listen': {'type': 'address', 'address': '192.168.0.1'}}
self.assertDictEqual(virt.running('myvm',
cpu=2,
mem=2048,
os_type='linux',
arch='i686',
vm_type='qemu',
disk_profile='prod',
disks=disks,
nic_profile='prod',
interfaces=ifaces,
graphics=graphics,
seed=False,
install=False,
pub_key='/path/to/key.pub',
priv_key='/path/to/key',
connection='someconnection',
username='******',
password='******'), ret)
init_mock.assert_called_with('myvm',
cpu=2,
mem=2048,
os_type='linux',
arch='i686',
image=None,
disk='prod',
disks=disks,
nic='prod',
interfaces=ifaces,
graphics=graphics,
hypervisor='qemu',
seed=False,
install=False,
pub_key='/path/to/key.pub',
priv_key='/path/to/key',
connection='someconnection',
username='******',
password='******')
with patch.dict(virt.__salt__, { # pylint: disable=no-member
'virt.vm_state': MagicMock(return_value={'myvm': 'stopped'}),
'virt.start': MagicMock(side_effect=[self.mock_libvirt.libvirtError('libvirt error msg')])
}):
ret.update({'changes': {}, 'result': False, 'comment': 'libvirt error msg'})
self.assertDictEqual(virt.running('myvm'), ret)
# Working update case when running
with patch.dict(virt.__salt__, { # pylint: disable=no-member
'virt.vm_state': MagicMock(return_value={'myvm': 'running'}),
'virt.update': MagicMock(return_value={'definition': True, 'cpu': True})
}):
ret.update({'changes': {'myvm': {'definition': True, 'cpu': True}},
'result': True,
'comment': 'Domain myvm updated, restart to fully apply the changes'})
self.assertDictEqual(virt.running('myvm', update=True, cpu=2), ret)
# Working update case when stopped
with patch.dict(virt.__salt__, { # pylint: disable=no-member
'virt.vm_state': MagicMock(return_value={'myvm': 'stopped'}),
'virt.start': MagicMock(return_value=0),
'virt.update': MagicMock(return_value={'definition': True})
}):
ret.update({'changes': {'myvm': 'Domain updated and started'},
'result': True,
'comment': 'Domain myvm updated and started'})
self.assertDictEqual(virt.running('myvm', update=True, cpu=2), ret)
# Failed live update case
with patch.dict(virt.__salt__, { # pylint: disable=no-member
'virt.vm_state': MagicMock(return_value={'myvm': 'running'}),
'virt.update': MagicMock(return_value={'definition': True, 'cpu': False, 'errors': ['some error']})
}):
ret.update({'changes': {'myvm': {'definition': True, 'cpu': False, 'errors': ['some error']}},
'result': True,
'comment': 'Domain myvm updated, but some live update(s) failed'})
self.assertDictEqual(virt.running('myvm', update=True, cpu=2), ret)
# Failed definition update case
with patch.dict(virt.__salt__, { # pylint: disable=no-member
'virt.vm_state': MagicMock(return_value={'myvm': 'running'}),
'virt.update': MagicMock(side_effect=[self.mock_libvirt.libvirtError('error message')])
}):
ret.update({'changes': {},
'result': False,
'comment': 'error message'})
self.assertDictEqual(virt.running('myvm', update=True, cpu=2), ret)
def test_running_define(test):
"""
running state test, defining and start a guest the old way
"""
with patch.dict(virt.__opts__, {"test": test}):
init_mock = MagicMock(return_value=True)
start_mock = MagicMock(return_value=0)
with patch.dict(
virt.__salt__,
{
"virt.vm_state": MagicMock(return_value={"myvm": "stopped"}),
"virt.init": init_mock,
"virt.start": start_mock,
"virt.list_domains": MagicMock(return_value=[]),
},
):
disks = [
{
"name": "system",
"size": 8192,
"overlay_image": True,
"pool": "default",
"image": "/path/to/image.qcow2",
},
{
"name": "data",
"size": 16834
},
]
ifaces = [
{
"name": "eth0",
"mac": "01:23:45:67:89:AB"
},
{
"name": "eth1",
"type": "network",
"source": "admin"
},
]
graphics = {
"type": "spice",
"listen": {
"type": "address",
"address": "192.168.0.1"
},
}
assert virt.running(
"myvm",
cpu=2,
mem=2048,
os_type="linux",
arch="i686",
vm_type="qemu",
disk_profile="prod",
disks=disks,
nic_profile="prod",
interfaces=ifaces,
graphics=graphics,
seed=False,
install=False,
pub_key="/path/to/key.pub",
priv_key="/path/to/key",
boot_dev="network hd",
stop_on_reboot=True,
host_devices=["pci_0000_00_17_0"],
connection="someconnection",
username="******",
password="******",
) == {
"name": "myvm",
"result": True if not test else None,
"changes": {
"myvm": {
"definition": True,
"started": True
}
},
"comment": "Domain myvm defined and started",
}
if not test:
init_mock.assert_called_with(
"myvm",
cpu=2,
mem=2048,
os_type="linux",
arch="i686",
disk="prod",
disks=disks,
nic="prod",
interfaces=ifaces,
graphics=graphics,
hypervisor="qemu",
seed=False,
boot=None,
numatune=None,
install=False,
start=False,
pub_key="/path/to/key.pub",
priv_key="/path/to/key",
boot_dev="network hd",
hypervisor_features=None,
clock=None,
stop_on_reboot=True,
connection="someconnection",
username="******",
password="******",
serials=None,
consoles=None,
host_devices=["pci_0000_00_17_0"],
)
start_mock.assert_called_with(
"myvm",
connection="someconnection",
username="******",
password="******",
)
else:
init_mock.assert_not_called()
start_mock.assert_not_called()
