mirror of
https://github.com/saltstack/salt.git
synced 2025-04-17 10:10:20 +00:00
34fb50b134
* Fix typos (`the the` > `the`) It looks like humans aren't only very bad at recognizing a double `the` in a sentence when reading [1], but they're also very good at sneaking them in unintentionally without noticing. Fix this by running: ``` ack --ignore-dir=doc/man --ignore-dir=doc/topics/releases -i 'the the\W' -l | xargs sed -i 's|the the\(\W\)|the\1|g' ``` [1] Eye movements and word skipping during reading: Effects of word length and predictability: https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3543826/ * Blacken changed files * Blacken changed files * Re-add unintentional delete * Bad merge fix * Fix broken docstring * Another try * pre-commit should pass now? Co-authored-by: Daniel A. Wozniak <dwozniak@saltstack.com> Co-authored-by: Wayne Werner <wwerner@saltstack.com>
1722 lines
57 KiB
Python
1722 lines
57 KiB
Python
# -*- coding: utf-8 -*-
|
|
"""
|
|
:codeauthor: Nicole Thomas <nicole@saltstack.com>
|
|
"""
|
|
|
|
# Import Python libs
|
|
from __future__ import absolute_import, print_function, unicode_literals
|
|
|
|
# Import Salt Libs
|
|
from salt.cloud.clouds import opennebula
|
|
from salt.exceptions import SaltCloudNotFound, SaltCloudSystemExit
|
|
|
|
# Import Salt Testing Libs
|
|
from tests.support.mixins import LoaderModuleMockMixin
|
|
from tests.support.mock import MagicMock, patch
|
|
from tests.support.unit import TestCase, skipIf
|
|
|
|
# Import Third Party Libs
|
|
try:
|
|
from lxml import etree # pylint: disable=W0611
|
|
|
|
HAS_XML_LIBS = True
|
|
except ImportError:
|
|
HAS_XML_LIBS = False
|
|
|
|
VM_NAME = "my-vm"
|
|
|
|
|
|
class OpenNebulaTestCase(TestCase, LoaderModuleMockMixin):
|
|
"""
|
|
Unit TestCase for salt.cloud.clouds.opennebula module.
|
|
"""
|
|
|
|
def setup_loader_modules(self):
|
|
return {
|
|
opennebula: {
|
|
"__virtual__": MagicMock(return_value="opennebula"),
|
|
"__utils__": {"cloud.cache_node": MagicMock()},
|
|
"__active_provider_name__": "",
|
|
}
|
|
}
|
|
|
|
def test_avail_images_action(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit error is raised when trying to call
|
|
avail_images with --action or -a.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.avail_images, "action")
|
|
|
|
def test_avail_locations_action(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when trying to call avail_locations
|
|
with --action or -a.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.avail_locations, "action")
|
|
|
|
def test_avail_sizes_action(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when trying to call avail_sizes
|
|
with --action or -a.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.avail_sizes, "action")
|
|
|
|
def test_avail_sizes(self):
|
|
"""
|
|
Tests that avail_sizes returns an empty dictionary.
|
|
"""
|
|
self.assertEqual(opennebula.avail_sizes(call="foo"), {})
|
|
|
|
def test_list_clusters_action(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when trying to call list_clusters
|
|
with --action or -a.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.list_clusters, "action")
|
|
|
|
def test_list_datastores_action(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when trying to call list_datastores
|
|
with --action or -a.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.list_datastores, "action")
|
|
|
|
def test_list_hosts_action(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when trying to call list_datastores
|
|
with --action or -a.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.list_hosts, "action")
|
|
|
|
def test_list_nodes_action(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when trying to call list_nodes
|
|
with --action or -a.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.list_nodes, "action")
|
|
|
|
def test_list_nodes_full_action(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when trying to call list_nodes_full
|
|
with --action or -a.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.list_nodes_full, "action")
|
|
|
|
def test_list_nodes_select_action(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when trying to call list_nodes_full
|
|
with --action or -a.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.list_nodes_select, "action")
|
|
|
|
def test_list_security_groups_action(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when trying to call
|
|
list_security_groups with --action or -a.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.list_security_groups, "action"
|
|
)
|
|
|
|
def test_list_templates_action(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when trying to call list_templates
|
|
with --action or -a.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.list_templates, "action")
|
|
|
|
def test_list_vns_action(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when trying to call list_vns
|
|
with --action or -a.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.list_vns, "action")
|
|
|
|
def test_reboot_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when trying to call reboot
|
|
with anything other that --action or -a.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.reboot, "my-vm", "foo")
|
|
|
|
def test_start_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when trying to call start
|
|
with anything other that --action or -a.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.start, "my-vm", "foo")
|
|
|
|
def test_stop_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when trying to call stop
|
|
with anything other that --action or -a.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.stop, "my-vm", "foo")
|
|
|
|
def test_get_cluster_id_action(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when trying to call
|
|
get_cluster_id with --action or -a.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.get_cluster_id, call="action")
|
|
|
|
def test_get_cluster_id_no_name(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when no name is provided.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.get_cluster_id, None, call="foo"
|
|
)
|
|
|
|
def test_get_cluster_id_not_found(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when no name is provided.
|
|
"""
|
|
with patch(
|
|
"salt.cloud.clouds.opennebula.list_clusters",
|
|
MagicMock(return_value={"foo": {"id": "bar"}}),
|
|
):
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.get_cluster_id,
|
|
kwargs={"name": "test"},
|
|
call="function",
|
|
)
|
|
|
|
def test_get_cluster_id_success(self):
|
|
"""
|
|
Tests that the function returns successfully.
|
|
"""
|
|
with patch(
|
|
"salt.cloud.clouds.opennebula.list_clusters",
|
|
MagicMock(return_value={"test-cluster": {"id": "100"}}),
|
|
):
|
|
mock_id = "100"
|
|
mock_kwargs = {"name": "test-cluster"}
|
|
self.assertEqual(opennebula.get_cluster_id(mock_kwargs, "foo"), mock_id)
|
|
|
|
def test_get_datastore_id_action(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when trying to call
|
|
get_datastore_id with --action or -a.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.get_datastore_id, call="action"
|
|
)
|
|
|
|
def test_get_datastore_id_no_name(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when no name is provided.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.get_datastore_id, None, call="foo"
|
|
)
|
|
|
|
def test_get_datastore_id_not_found(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when no name is provided.
|
|
"""
|
|
with patch(
|
|
"salt.cloud.clouds.opennebula.list_datastores",
|
|
MagicMock(return_value={"test-datastore": {"id": "100"}}),
|
|
):
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.get_datastore_id,
|
|
kwargs={"name": "test"},
|
|
call="function",
|
|
)
|
|
|
|
def test_get_datastore_id_success(self):
|
|
"""
|
|
Tests that the function returns successfully.
|
|
"""
|
|
with patch(
|
|
"salt.cloud.clouds.opennebula.list_datastores",
|
|
MagicMock(return_value={"test-datastore": {"id": "100"}}),
|
|
):
|
|
mock_id = "100"
|
|
mock_kwargs = {"name": "test-datastore"}
|
|
self.assertEqual(opennebula.get_datastore_id(mock_kwargs, "foo"), mock_id)
|
|
|
|
def test_get_host_id_action(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when trying to call
|
|
get_host_id with --action or -a.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.get_host_id, call="action")
|
|
|
|
def test_get_host_id_no_name(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when no name is provided.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.get_host_id, None, call="foo")
|
|
|
|
def test_get_host_id_not_found(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when no name is provided.
|
|
"""
|
|
with patch(
|
|
"salt.cloud.clouds.opennebula.avail_locations",
|
|
MagicMock(return_value={"test-host": {"id": "100"}}),
|
|
):
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.get_host_id,
|
|
kwargs={"name": "test"},
|
|
call="function",
|
|
)
|
|
|
|
def test_get_host_id_success(self):
|
|
"""
|
|
Tests that the function returns successfully.
|
|
"""
|
|
with patch(
|
|
"salt.cloud.clouds.opennebula.avail_locations",
|
|
MagicMock(return_value={"test-host": {"id": "100"}}),
|
|
):
|
|
mock_id = "100"
|
|
mock_kwargs = {"name": "test-host"}
|
|
self.assertEqual(opennebula.get_host_id(mock_kwargs, "foo"), mock_id)
|
|
|
|
def test_get_image_not_found(self):
|
|
"""
|
|
Tests that a SaltCloudNotFound is raised when the image doesn't exist.
|
|
"""
|
|
with patch(
|
|
"salt.cloud.clouds.opennebula.avail_images", MagicMock(return_value={})
|
|
):
|
|
with patch(
|
|
"salt.config.get_cloud_config_value", MagicMock(return_value="foo")
|
|
):
|
|
self.assertRaises(SaltCloudNotFound, opennebula.get_image, "my-vm")
|
|
|
|
def test_get_image_success(self):
|
|
"""
|
|
Tests that the image is returned successfully.
|
|
"""
|
|
with patch(
|
|
"salt.cloud.clouds.opennebula.avail_images",
|
|
MagicMock(return_value={"my-vm": {"name": "my-vm", "id": 0}}),
|
|
):
|
|
with patch(
|
|
"salt.config.get_cloud_config_value", MagicMock(return_value="my-vm")
|
|
):
|
|
self.assertEqual(opennebula.get_image("my-vm"), 0)
|
|
|
|
def test_get_image_id_action(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when trying to call
|
|
get_image_id with --action or -a.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.get_image_id, call="action")
|
|
|
|
def test_get_image_id_no_name(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when no name is provided.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.get_image_id, None, call="foo"
|
|
)
|
|
|
|
def test_get_image_id_not_found(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when no name is provided.
|
|
"""
|
|
with patch(
|
|
"salt.cloud.clouds.opennebula.avail_images",
|
|
MagicMock(return_value={"test-image": {"id": "100"}}),
|
|
):
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.get_image_id,
|
|
kwargs={"name": "test"},
|
|
call="function",
|
|
)
|
|
|
|
def test_get_image_id_success(self):
|
|
"""
|
|
Tests that the function returns successfully.
|
|
"""
|
|
with patch(
|
|
"salt.cloud.clouds.opennebula.avail_images",
|
|
MagicMock(return_value={"test-image": {"id": "100"}}),
|
|
):
|
|
mock_id = "100"
|
|
mock_kwargs = {"name": "test-image"}
|
|
self.assertEqual(opennebula.get_image_id(mock_kwargs, "foo"), mock_id)
|
|
|
|
def test_get_location_not_found(self):
|
|
"""
|
|
Tests that a SaltCloudNotFound is raised when the location doesn't exist.
|
|
"""
|
|
with patch(
|
|
"salt.cloud.clouds.opennebula.avail_locations", MagicMock(return_value={})
|
|
):
|
|
with patch(
|
|
"salt.config.get_cloud_config_value", MagicMock(return_value="foo")
|
|
):
|
|
self.assertRaises(SaltCloudNotFound, opennebula.get_location, "my-vm")
|
|
|
|
def test_get_location_success(self):
|
|
"""
|
|
Tests that the image is returned successfully.
|
|
"""
|
|
with patch(
|
|
"salt.cloud.clouds.opennebula.avail_locations",
|
|
MagicMock(return_value={"my-host": {"name": "my-host", "id": 0}}),
|
|
):
|
|
with patch(
|
|
"salt.config.get_cloud_config_value", MagicMock(return_value="my-host")
|
|
):
|
|
self.assertEqual(opennebula.get_location("my-host"), 0)
|
|
|
|
def test_get_secgroup_id_action(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when trying to call
|
|
get_host_id with --action or -a.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.get_secgroup_id, call="action"
|
|
)
|
|
|
|
def test_get_secgroup_id_no_name(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when no name is provided.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.get_secgroup_id, None, call="foo"
|
|
)
|
|
|
|
def test_get_secgroup_id_not_found(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when no name is provided.
|
|
"""
|
|
with patch(
|
|
"salt.cloud.clouds.opennebula.list_security_groups",
|
|
MagicMock(return_value={"test-security-group": {"id": "100"}}),
|
|
):
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.get_secgroup_id,
|
|
kwargs={"name": "test"},
|
|
call="function",
|
|
)
|
|
|
|
def test_get_secgroup_id_success(self):
|
|
"""
|
|
Tests that the function returns successfully.
|
|
"""
|
|
with patch(
|
|
"salt.cloud.clouds.opennebula.list_security_groups",
|
|
MagicMock(return_value={"test-secgroup": {"id": "100"}}),
|
|
):
|
|
mock_id = "100"
|
|
mock_kwargs = {"name": "test-secgroup"}
|
|
self.assertEqual(opennebula.get_secgroup_id(mock_kwargs, "foo"), mock_id)
|
|
|
|
def test_get_template_id_action(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when trying to call
|
|
get_template_id with --action or -a.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.get_template_id, call="action"
|
|
)
|
|
|
|
def test_get_template_id_no_name(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when no name is provided.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.get_template_id, None, call="foo"
|
|
)
|
|
|
|
def test_get_template_id_not_found(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when no name is provided.
|
|
"""
|
|
with patch(
|
|
"salt.cloud.clouds.opennebula.list_templates",
|
|
MagicMock(return_value={"test-template": {"id": "100"}}),
|
|
):
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.get_template_id,
|
|
kwargs={"name": "test"},
|
|
call="function",
|
|
)
|
|
|
|
def test_get_template_id_success(self):
|
|
"""
|
|
Tests that the function returns successfully.
|
|
"""
|
|
with patch(
|
|
"salt.cloud.clouds.opennebula.list_templates",
|
|
MagicMock(return_value={"test-template": {"id": "100"}}),
|
|
):
|
|
mock_id = "100"
|
|
mock_kwargs = {"name": "test-template"}
|
|
self.assertEqual(opennebula.get_template_id(mock_kwargs, "foo"), mock_id)
|
|
|
|
def test_get_vm_id_action(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when trying to call
|
|
get_vm_id with --action or -a.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.get_vm_id, call="action")
|
|
|
|
def test_get_vm_id_no_name(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when no name is provided.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.get_vm_id, None, call="foo")
|
|
|
|
def test_get_vm_id_not_found(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when no name is provided.
|
|
"""
|
|
with patch(
|
|
"salt.cloud.clouds.opennebula.list_nodes",
|
|
MagicMock(return_value={"test-vm": {"id": "100"}}),
|
|
):
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.get_vm_id,
|
|
kwargs={"name": "test"},
|
|
call="function",
|
|
)
|
|
|
|
def test_get_vm_id_success(self):
|
|
"""
|
|
Tests that the function returns successfully.
|
|
"""
|
|
with patch(
|
|
"salt.cloud.clouds.opennebula.list_nodes",
|
|
MagicMock(return_value={"test-vm": {"id": "100"}}),
|
|
):
|
|
mock_id = "100"
|
|
mock_kwargs = {"name": "test-vm"}
|
|
self.assertEqual(opennebula.get_vm_id(mock_kwargs, "foo"), mock_id)
|
|
|
|
def test_get_vn_id_action(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when trying to call
|
|
get_vn_id with --action or -a.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.get_vn_id, call="action")
|
|
|
|
def test_get_vn_id_no_name(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when no name is provided.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.get_vn_id, None, call="foo")
|
|
|
|
def test_get_vn_id_not_found(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when no name is provided.
|
|
"""
|
|
with patch(
|
|
"salt.cloud.clouds.opennebula.list_vns",
|
|
MagicMock(return_value={"test-vn": {"id": "100"}}),
|
|
):
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.get_vn_id,
|
|
kwargs={"name": "test"},
|
|
call="function",
|
|
)
|
|
|
|
def test_get_vn_id_success(self):
|
|
"""
|
|
Tests that the function returns successfully.
|
|
"""
|
|
with patch(
|
|
"salt.cloud.clouds.opennebula.list_vns",
|
|
MagicMock(return_value={"test-vn": {"id": "100"}}),
|
|
):
|
|
mock_id = "100"
|
|
mock_kwargs = {"name": "test-vn"}
|
|
self.assertEqual(opennebula.get_vn_id(mock_kwargs, "foo"), mock_id)
|
|
|
|
# TODO: Write tests for create function
|
|
|
|
def test_destroy_function_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when --function or -f is provided.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.destroy, "my-vm", "function")
|
|
|
|
def test_image_allocate_function_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--function or -f is provided.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.image_allocate, "foo")
|
|
|
|
def test_image_allocate_no_name_or_datastore_id(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when a neither a datastore_id
|
|
nor a datastore_name is provided.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.image_allocate, "function")
|
|
|
|
def test_image_allocate_no_path_or_data(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when neither the path nor data args
|
|
are provided.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.image_allocate,
|
|
"function",
|
|
kwargs={"datastore_id": "5"},
|
|
)
|
|
|
|
def test_image_clone_function_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--function or -f is provided.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.image_clone, "foo")
|
|
|
|
def test_image_clone_no_name(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when a name isn't provided.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.image_clone, "function")
|
|
|
|
def test_image_clone_no_image_id_or_image_name(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when neither the image_id nor
|
|
the image_name args are provided.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.image_clone,
|
|
"function",
|
|
kwargs={"name": "test"},
|
|
)
|
|
|
|
@skipIf(True, "Need to figure out how to mock calls to the O.N. API first.")
|
|
def test_image_clone_success(self):
|
|
"""
|
|
Tests that image_clone returns successfully
|
|
"""
|
|
with patch("image.clone", MagicMock(return_value=[True, 11, 0])):
|
|
name = "test-image"
|
|
expected = {
|
|
"action": "image.clone",
|
|
"cloned": "True",
|
|
"cloned_image_id": "11",
|
|
"cloned_image_name": name,
|
|
"error_code": "0",
|
|
}
|
|
ret = opennebula.image_clone(
|
|
"function", kwargs={"name": name, "image_id": 1}
|
|
)
|
|
self.assertEqual(expected, ret)
|
|
|
|
def test_image_delete_function_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--function or -f is provided.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.image_delete, "foo")
|
|
|
|
def test_image_delete_no_name_or_image_id(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when a neither an image_id
|
|
nor a name is provided.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.image_delete, "function")
|
|
|
|
def test_image_info_function_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--function or -f is provided.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.image_info, "foo")
|
|
|
|
def test_image_info_no_image_id_or_image_name(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when a neither an image_id
|
|
nor a name is provided.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.image_info, "function")
|
|
|
|
def test_image_persist_function_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--function or -f is provided.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.image_persistent, "foo")
|
|
|
|
def test_image_persist_no_persist(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the persist kwarg is missing.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.image_persistent, "function")
|
|
|
|
def test_image_persist_no_name_or_image_id(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when a neither an image_id
|
|
nor a name is provided.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.image_delete,
|
|
"function",
|
|
kwargs={"persist": False},
|
|
)
|
|
|
|
def test_image_snapshot_delete_function_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--function or -f is provided.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.image_snapshot_delete, call="foo"
|
|
)
|
|
|
|
def test_image_snapshot_delete_no_snapshot_id(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the snapshot_id kwarg is
|
|
missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.image_snapshot_delete,
|
|
call="function",
|
|
kwargs=None,
|
|
)
|
|
|
|
def test_image_snapshot_delete_no_image_name_or_image_id(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the image_id and image_name
|
|
kwargs are missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.image_snapshot_delete,
|
|
call="function",
|
|
kwargs={"snapshot_id": 0},
|
|
)
|
|
|
|
def test_image_snapshot_revert_function_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--function or -f is provided.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.image_snapshot_revert, call="foo"
|
|
)
|
|
|
|
def test_image_snapshot_revert_no_snapshot_id(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the snapshot_id kwarg is
|
|
missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.image_snapshot_revert,
|
|
call="function",
|
|
kwargs=None,
|
|
)
|
|
|
|
def test_image_snapshot_revert_no_image_name_or_image_id(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the image_id and image_name
|
|
kwargs are missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.image_snapshot_revert,
|
|
call="function",
|
|
kwargs={"snapshot_id": 0},
|
|
)
|
|
|
|
def test_image_snapshot_flatten_function_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--function or -f is provided.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.image_snapshot_flatten, call="foo"
|
|
)
|
|
|
|
def test_image_snapshot_flatten_no_snapshot_id(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the snapshot_id kwarg is
|
|
missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.image_snapshot_flatten,
|
|
call="function",
|
|
kwargs=None,
|
|
)
|
|
|
|
def test_image_snapshot_flatten_no_image_name_or_image_id(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the image_id and image_name
|
|
kwargs are missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.image_snapshot_flatten,
|
|
call="function",
|
|
kwargs={"snapshot_id": 0},
|
|
)
|
|
|
|
def test_image_update_function_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--function or -f is provided.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.image_update, "foo")
|
|
|
|
def test_image_update_no_update_type(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the update_type kwarg is
|
|
missing.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.image_update, "function")
|
|
|
|
def test_image_update_bad_update_type_value(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the update_type kwarg is
|
|
not a valid value.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.image_update,
|
|
"function",
|
|
kwargs={"update_type": "foo"},
|
|
)
|
|
|
|
def test_image_update_no_image_id_or_image_name(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the image_id and image_name
|
|
kwargs are missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.image_update,
|
|
"function",
|
|
kwargs={"update_type": "merge"},
|
|
)
|
|
|
|
def test_image_update_no_data_or_path(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the data and path
|
|
kwargs are missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.image_update,
|
|
"function",
|
|
kwargs={"update_type": "merge", "image_id": "0"},
|
|
)
|
|
|
|
def test_show_instance_action_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--action or -a is provided.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.show_instance, VM_NAME, call="foo"
|
|
)
|
|
|
|
def test_show_instance_success(self):
|
|
"""
|
|
Tests that the node was found successfully.
|
|
"""
|
|
with patch(
|
|
"salt.cloud.clouds.opennebula._get_node",
|
|
MagicMock(return_value={"my-vm": {"name": "my-vm", "id": 0}}),
|
|
):
|
|
ret = {"my-vm": {"name": "my-vm", "id": 0}}
|
|
self.assertEqual(opennebula.show_instance("my-vm", call="action"), ret)
|
|
|
|
def test_secgroup_allocate_function_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--function or -f is provided.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.secgroup_allocate, "foo")
|
|
|
|
def test_secgroup_allocate_no_data_or_path(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the data and path
|
|
kwargs are missing.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.secgroup_allocate, "function")
|
|
|
|
def test_secgroup_clone_function_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--function or -f is provided.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.secgroup_clone, "foo")
|
|
|
|
def test_secgroup_clone_no_name(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the name kwarg is
|
|
missing.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.secgroup_clone, "function")
|
|
|
|
def test_secgroup_clone_no_secgroup_id_or_secgroup_name(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the secgroup_id and
|
|
secgroup_name kwargs are missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.secgroup_clone,
|
|
"function",
|
|
kwargs={"name": "test"},
|
|
)
|
|
|
|
def test_secgroup_delete_function_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--function or -f is provided.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.secgroup_delete, "foo")
|
|
|
|
def test_secgroup_delete_no_secgroup_id_or_name(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the secgroup_id and
|
|
name kwargs are missing.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.secgroup_clone, "function")
|
|
|
|
def test_secgroup_info_function_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--function or -f is provided.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.secgroup_info, "foo")
|
|
|
|
def test_secgroup_info_no_secgroup_id_or_name(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the secgroup_id and
|
|
name kwargs are missing.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.secgroup_info, "function")
|
|
|
|
def test_secgroup_update_function_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--function or -f is provided.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.secgroup_update, "foo")
|
|
|
|
def test_secgroup_update_no_update_type(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the update_type arg is
|
|
missing.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.secgroup_update, "function")
|
|
|
|
def test_secgroup_update_bad_update_type_value(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the update_type contains
|
|
an invalid value.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.secgroup_update,
|
|
"function",
|
|
kwargs={"update_type": "foo"},
|
|
)
|
|
|
|
def test_secgroup_update_no_secgroup_id_or_secgroup_name(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the secgroup_id and
|
|
secgroup_name kwargs are missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.secgroup_update,
|
|
"function",
|
|
kwargs={"update_type": "merge"},
|
|
)
|
|
|
|
def test_secgroup_update_no_data_or_path(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the data and
|
|
path kwargs are missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.secgroup_update,
|
|
"function",
|
|
kwargs={"update_type": "merge", "secgroup_id": "0"},
|
|
)
|
|
|
|
def test_template_allocate_function_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--function or -f is provided.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.template_allocate, "foo")
|
|
|
|
def test_template_allocate_no_data_or_path(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the data and
|
|
path kwargs are missing.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.template_allocate, "function")
|
|
|
|
def test_template_clone_function_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--function or -f is provided.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.template_clone, "foo")
|
|
|
|
def test_template_clone_no_name(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the name arg is missing.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.template_clone, "function")
|
|
|
|
def test_template_clone_no_template_name_or_template_id(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the template_name and
|
|
template_id args are missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.template_clone,
|
|
"function",
|
|
kwargs={"name": "foo"},
|
|
)
|
|
|
|
def test_template_delete_function_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--function or -f is provided.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.template_delete, "foo")
|
|
|
|
def test_template_delete_no_name_or_template_id(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the name and
|
|
template_id args are missing.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.template_delete, "function")
|
|
|
|
def test_template_instantiate_function_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--function or -f is provided.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.template_instantiate, "foo")
|
|
|
|
def test_template_instantiate_no_vm_name(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the vm_name arg is missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.template_instantiate, "function", None
|
|
)
|
|
|
|
def test_template_instantiate_no_template_id_or_template_name(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the template_name and
|
|
template_id args are missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.template_instantiate,
|
|
"function",
|
|
kwargs={"vm_name": "test"},
|
|
)
|
|
|
|
def test_template_update_function_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--function or -f is provided.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.template_update, call="foo")
|
|
|
|
def test_template_update_bad_update_type_value(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the update_type contains
|
|
and invalid value.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.template_update,
|
|
call="function",
|
|
kwargs={"update_type": "foo"},
|
|
)
|
|
|
|
def test_template_update_no_template_id_or_template_name(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the template_id and the
|
|
template_name args are missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.template_update,
|
|
call="function",
|
|
kwargs={"update_type": "merge"},
|
|
)
|
|
|
|
def test_template_update_no_data_or_path(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the data and the
|
|
path args are missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.template_update,
|
|
call="function",
|
|
kwargs={"update_type": "merge", "template_id": "0"},
|
|
)
|
|
|
|
def test_vm_action_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--action or -a is provided.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.vm_action, VM_NAME, call="foo"
|
|
)
|
|
|
|
def test_vm_action_no_action(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the action arg is missing
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.vm_action, VM_NAME, call="action"
|
|
)
|
|
|
|
def test_vm_allocate_function_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--function or -f is provided.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.vm_allocate, "foo")
|
|
|
|
def test_vm_allocate_no_data_or_path(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the data and
|
|
path kwargs are missing.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.vm_allocate, "function")
|
|
|
|
def test_vm_attach_action_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--action or -a is provided.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.vm_attach, VM_NAME, call="foo"
|
|
)
|
|
|
|
def test_vm_attach_no_data_or_path(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the data and
|
|
path kwargs are missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.vm_attach, VM_NAME, call="action"
|
|
)
|
|
|
|
def test_vm_attach_nic_action_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--action or -a is provided.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.vm_attach_nic, VM_NAME, call="foo"
|
|
)
|
|
|
|
def test_vm_attach_nic_no_data_or_path(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the data and
|
|
path kwargs are missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.vm_attach_nic, VM_NAME, call="action"
|
|
)
|
|
|
|
def test_vm_deploy_action_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--action or -a is provided.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.vm_deploy, VM_NAME, call="foo"
|
|
)
|
|
|
|
def test_vm_deploy_no_host_id_or_host_name(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the host_id and the
|
|
host_name args are missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.vm_deploy,
|
|
VM_NAME,
|
|
call="action",
|
|
kwargs=None,
|
|
)
|
|
|
|
def test_vm_detach_action_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--action or -a is provided.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.vm_detach, VM_NAME, call="foo"
|
|
)
|
|
|
|
def test_vm_detach_no_disk_id(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the disk_id ar is missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.vm_detach, VM_NAME, call="action"
|
|
)
|
|
|
|
def test_vm_detach_nic_action_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--action or -a is provided.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.vm_detach_nic, VM_NAME, call="foo"
|
|
)
|
|
|
|
def test_vm_detach_nic_no_nic_id(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the nic_id arg is missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.vm_detach_nic, VM_NAME, call="action"
|
|
)
|
|
|
|
def test_vm_disk_save_action_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--action or -a is provided.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.vm_disk_save, VM_NAME, call="foo"
|
|
)
|
|
|
|
def test_vm_disk_save_no_disk_id(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the disk_id arg is missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.vm_disk_save,
|
|
VM_NAME,
|
|
call="action",
|
|
kwargs={"image_name": "foo"},
|
|
)
|
|
|
|
def test_vm_disk_save_no_image_name(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the image_name arg is missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.vm_disk_save,
|
|
VM_NAME,
|
|
call="action",
|
|
kwargs={"disk_id": "0"},
|
|
)
|
|
|
|
def test_vm_disk_snapshot_create_action_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--action or -a is provided.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.vm_disk_snapshot_create, VM_NAME, call="foo"
|
|
)
|
|
|
|
def test_vm_disk_snapshot_create_no_disk_id(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the disk_id arg is missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.vm_disk_snapshot_create,
|
|
VM_NAME,
|
|
call="action",
|
|
kwargs={"description": "foo"},
|
|
)
|
|
|
|
def test_vm_disk_snapshot_create_no_description(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the image_name arg is missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.vm_disk_snapshot_create,
|
|
VM_NAME,
|
|
call="action",
|
|
kwargs={"disk_id": "0"},
|
|
)
|
|
|
|
def test_vm_disk_snapshot_delete_action_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--action or -a is provided.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.vm_disk_snapshot_delete, VM_NAME, call="foo"
|
|
)
|
|
|
|
def test_vm_disk_snapshot_delete_no_disk_id(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the disk_id arg is missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.vm_disk_snapshot_delete,
|
|
VM_NAME,
|
|
call="action",
|
|
kwargs={"snapshot_id": "0"},
|
|
)
|
|
|
|
def test_vm_disk_snapshot_delete_no_snapshot_id(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the snapshot_id arg is missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.vm_disk_snapshot_delete,
|
|
VM_NAME,
|
|
call="action",
|
|
kwargs={"disk_id": "0"},
|
|
)
|
|
|
|
def test_vm_disk_snapshot_revert_action_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--action or -a is provided.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.vm_disk_snapshot_revert, VM_NAME, call="foo"
|
|
)
|
|
|
|
def test_vm_disk_snapshot_revert_no_disk_id(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the disk_id arg is missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.vm_disk_snapshot_revert,
|
|
VM_NAME,
|
|
call="action",
|
|
kwargs={"snapshot_id": "0"},
|
|
)
|
|
|
|
def test_vm_disk_snapshot_revert_no_snapshot_id(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the snapshot_id arg is missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.vm_disk_snapshot_revert,
|
|
VM_NAME,
|
|
call="action",
|
|
kwargs={"disk_id": "0"},
|
|
)
|
|
|
|
def test_vm_info_action_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--action or -a is provided.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.vm_info, VM_NAME, call="foo")
|
|
|
|
def test_vm_migrate_action_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--action or -a is provided.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.vm_migrate, VM_NAME, call="foo"
|
|
)
|
|
|
|
def test_vm_migrate_no_datastore_id_or_datastore_name(self):
|
|
"""
|
|
Tests that a SaltCLoudSystemExit is raised when the datastore_id and the
|
|
datastore_name args are missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.vm_migrate,
|
|
VM_NAME,
|
|
call="action",
|
|
kwargs=None,
|
|
)
|
|
|
|
def test_vm_migrate_no_host_id_or_host_name(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the host_id and the
|
|
host_name args are missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.vm_migrate,
|
|
VM_NAME,
|
|
call="action",
|
|
kwargs={"datastore_id": "0"},
|
|
)
|
|
|
|
def test_vm_monitoring_action_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--action or -a is provided.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.vm_monitoring, VM_NAME, call="foo"
|
|
)
|
|
|
|
def test_vm_resize_action_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--action or -a is provided.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.vm_resize, VM_NAME, call="foo"
|
|
)
|
|
|
|
def test_vm_resize_no_data_or_path(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the data and path args
|
|
are missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.vm_resize,
|
|
VM_NAME,
|
|
call="action",
|
|
kwargs=None,
|
|
)
|
|
|
|
def test_vm_snapshot_create_action_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--action or -a is provided.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.vm_snapshot_create, VM_NAME, call="foo"
|
|
)
|
|
|
|
def test_vm_snapshot_create_no_snapshot_name(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the snapshot_name arg
|
|
is missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.vm_snapshot_create,
|
|
VM_NAME,
|
|
call="action",
|
|
kwargs=None,
|
|
)
|
|
|
|
def test_vm_snapshot_delete_action_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--action or -a is provided.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.vm_snapshot_delete, VM_NAME, call="foo"
|
|
)
|
|
|
|
def test_vm_snapshot_delete_no_snapshot_id(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the snapshot_id arg
|
|
is missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.vm_snapshot_delete,
|
|
VM_NAME,
|
|
call="action",
|
|
kwargs=None,
|
|
)
|
|
|
|
def test_vm_snapshot_revert_action_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--action or -a is provided.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.vm_snapshot_revert, VM_NAME, call="foo"
|
|
)
|
|
|
|
def test_vm_snapshot_revert_no_snapshot_id(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the snapshot_id arg
|
|
is missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.vm_snapshot_revert,
|
|
VM_NAME,
|
|
call="action",
|
|
kwargs=None,
|
|
)
|
|
|
|
def test_vm_update_action_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--action or -a is provided.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.vm_update, VM_NAME, call="foo"
|
|
)
|
|
|
|
def test_vm_update_no_update_type(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the update_type arg
|
|
is missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.vm_update,
|
|
VM_NAME,
|
|
call="action",
|
|
kwargs=None,
|
|
)
|
|
|
|
def test_vm_update_bad_update_type_value(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the update_type kwarg is
|
|
not a valid value.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.vm_update,
|
|
VM_NAME,
|
|
call="action",
|
|
kwargs={"update_type": "foo"},
|
|
)
|
|
|
|
def test_vm_update_no_data_or_path(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the data and path args
|
|
are missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.vm_update,
|
|
VM_NAME,
|
|
call="action",
|
|
kwargs={"update_type": "merge"},
|
|
)
|
|
|
|
def test_vn_add_ar_function_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--function or -f is provided.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.vn_add_ar, call="foo")
|
|
|
|
def test_vn_add_ar_no_vn_id_or_vn_name(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the vn_id and vn_name
|
|
args are missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.vn_add_ar, call="function", kwargs=None
|
|
)
|
|
|
|
def test_vn_add_ar_no_path_or_data(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the path and data
|
|
args are missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.vn_add_ar,
|
|
call="function",
|
|
kwargs={"vn_id": "0"},
|
|
)
|
|
|
|
def test_vn_allocate_function_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--function or -f is provided.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.vn_allocate, call="foo")
|
|
|
|
def test_vn_allocate_no_data_or_path(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the path and data
|
|
args are missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.vn_allocate, call="function", kwargs=None
|
|
)
|
|
|
|
def test_vn_delete_function_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--function or -f is provided.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.vn_delete, call="foo")
|
|
|
|
def test_vn_delete_no_vn_id_or_name(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the vn_id and name
|
|
args are missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.vn_delete, call="function", kwargs=None
|
|
)
|
|
|
|
def test_vn_free_ar_function_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--function or -f is provided.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.vn_free_ar, call="foo")
|
|
|
|
def test_vn_free_ar_no_ar_id(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the ar_id is missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.vn_free_ar, call="function", kwargs=None
|
|
)
|
|
|
|
def test_vn_free_ar_no_vn_id_or_vn_name(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the vn_id and vn_name
|
|
args are missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.vn_free_ar,
|
|
call="function",
|
|
kwargs={"ar_id": "0"},
|
|
)
|
|
|
|
def test_vn_hold_function_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--function or -f is provided.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.vn_hold, call="foo")
|
|
|
|
def test_vn_hold_no_vn_id_or_vn_name(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the vn_id and vn_name
|
|
args are missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.vn_hold, call="function", kwargs=None
|
|
)
|
|
|
|
def test_vn_hold_no_data_or_path(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the data and path
|
|
args are missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.vn_hold,
|
|
call="function",
|
|
kwargs={"vn_id": "0"},
|
|
)
|
|
|
|
def test_vn_info_function_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--function or -f is provided.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.vn_info, call="foo")
|
|
|
|
def test_vn_info_no_vn_id_or_vn_name(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the vn_id and vn_name
|
|
args are missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.vn_info, call="function", kwargs=None
|
|
)
|
|
|
|
def test_vn_release_function_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--function or -f is provided.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.vn_release, call="foo")
|
|
|
|
def test_vn_release_no_vn_id_or_vn_name(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the vn_id and vn_name
|
|
args are missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.vn_release, call="function", kwargs=None
|
|
)
|
|
|
|
def test_vn_release_no_data_or_path(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the data and path
|
|
args are missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.vn_release,
|
|
call="function",
|
|
kwargs={"vn_id": "0"},
|
|
)
|
|
|
|
def test_vn_reserve_function_error(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when something other than
|
|
--function or -f is provided.
|
|
"""
|
|
self.assertRaises(SaltCloudSystemExit, opennebula.vn_reserve, call="foo")
|
|
|
|
def test_vn_reserve_no_vn_id_or_vn_name(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the vn_id and vn_name
|
|
args are missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit, opennebula.vn_reserve, call="function", kwargs=None
|
|
)
|
|
|
|
def test_vn_reserve_no_data_or_path(self):
|
|
"""
|
|
Tests that a SaltCloudSystemExit is raised when the data and path
|
|
args are missing.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula.vn_reserve,
|
|
call="function",
|
|
kwargs={"vn_id": "0"},
|
|
)
|
|
|
|
@skipIf(not HAS_XML_LIBS, "cannot find lxml python library")
|
|
def test__get_xml(self):
|
|
"""
|
|
Tests that invalid XML raises SaltCloudSystemExit.
|
|
"""
|
|
self.assertRaises(
|
|
SaltCloudSystemExit,
|
|
opennebula._get_xml,
|
|
"[VirtualMachinePoolInfo] User couldn't be"
|
|
" authenticated, aborting call.",
|
|
)
|