import logging
import unittest
+import cinderclient.exceptions as cExceptions
from mock import MagicMock, patch
+from neutronclient.common import exceptions as neExceptions
from novaclient import exceptions as nvExceptions
from novaclient.exceptions import ClientException, Conflict
from osm_ro_plugin.vimconn import (
VimConnConnectionException,
VimConnException,
VimConnNotFoundException,
+ VimConnUnexpectedResponse,
)
from osm_rovim_openstack.vimconn_openstack import vimconnector
+from requests.exceptions import ConnectionError
__author__ = "Igor D.C."
__date__ = "$23-aug-2017 23:59:59$"
def test_prepare_persistent_root_volumes_vim_using_volume_id(self):
"""Existing persistent root volume with vim_volume_id."""
- vm_av_zone = ["nova"]
+ storage_av_zone = ["nova"]
base_disk_index = ord("a")
disk = {"vim_volume_id": volume_id}
block_device_mapping = {}
expected_existing_vim_volumes = [{"id": volume_id}]
boot_volume_id = self.vimconn._prepare_persistent_root_volumes(
name,
- vm_av_zone,
+ storage_av_zone,
disk,
base_disk_index,
block_device_mapping,
self, mock_update_block_device_mapping
):
"""Existing persistent non root volume with vim_volume_id."""
- vm_av_zone = ["nova"]
+ storage_av_zone = ["nova"]
base_disk_index = ord("b")
disk = {"vim_volume_id": volume_id}
block_device_mapping = {}
self.vimconn._prepare_non_root_persistent_volumes(
name,
disk,
- vm_av_zone,
+ storage_av_zone,
block_device_mapping,
base_disk_index,
existing_vim_volumes,
self, mock_update_block_device_mapping
):
"""Existing persistent root volume with vim_id."""
- vm_av_zone = ["nova"]
+ storage_av_zone = ["nova"]
base_disk_index = ord("a")
disk = {"vim_id": volume_id}
block_device_mapping = {}
expected_existing_vim_volumes = [{"id": volume_id}]
boot_volume_id = self.vimconn._prepare_persistent_root_volumes(
name,
- vm_av_zone,
+ storage_av_zone,
disk,
base_disk_index,
block_device_mapping,
self, mock_update_block_device_mapping
):
"""Existing persistent root volume with vim_id."""
- vm_av_zone = ["nova"]
+ storage_av_zone = ["nova"]
base_disk_index = ord("b")
disk = {"vim_id": volume_id}
block_device_mapping = {}
self.vimconn._prepare_non_root_persistent_volumes(
name,
disk,
- vm_av_zone,
+ storage_av_zone,
block_device_mapping,
base_disk_index,
existing_vim_volumes,
):
"""Create persistent root volume."""
self.vimconn.cinder.volumes.create.return_value.id = volume_id2
- vm_av_zone = ["nova"]
+ storage_av_zone = ["nova"]
base_disk_index = ord("a")
disk = {"size": 10, "image_id": image_id}
block_device_mapping = {}
expected_boot_vol_id = volume_id2
boot_volume_id = self.vimconn._prepare_persistent_root_volumes(
name,
- vm_av_zone,
+ storage_av_zone,
disk,
base_disk_index,
block_device_mapping,
):
"""Create persistent root volume, disk has keep parameter."""
self.vimconn.cinder.volumes.create.return_value.id = volume_id2
- vm_av_zone = ["nova"]
+ storage_av_zone = ["nova"]
base_disk_index = ord("a")
disk = {"size": 10, "image_id": image_id, "keep": True}
block_device_mapping = {}
expected_existing_vim_volumes = []
boot_volume_id = self.vimconn._prepare_persistent_root_volumes(
name,
- vm_av_zone,
+ storage_av_zone,
disk,
base_disk_index,
block_device_mapping,
"""Create persistent non-root volume."""
self.vimconn.cinder = CopyingMock()
self.vimconn.cinder.volumes.create.return_value.id = volume_id2
- vm_av_zone = ["nova"]
+ storage_av_zone = ["nova"]
base_disk_index = ord("a")
disk = {"size": 10}
block_device_mapping = {}
self.vimconn._prepare_non_root_persistent_volumes(
name,
disk,
- vm_av_zone,
+ storage_av_zone,
block_device_mapping,
base_disk_index,
existing_vim_volumes,
"""Create persistent non-root volume."""
self.vimconn.cinder = CopyingMock()
self.vimconn.cinder.volumes.create.return_value.id = volume_id2
- vm_av_zone = ["nova"]
+ storage_av_zone = ["nova"]
base_disk_index = ord("a")
disk = {"size": 10, "keep": True}
block_device_mapping = {}
self.vimconn._prepare_non_root_persistent_volumes(
name,
disk,
- vm_av_zone,
+ storage_av_zone,
block_device_mapping,
base_disk_index,
existing_vim_volumes,
@patch.object(vimconnector, "update_block_device_mapping")
def test_new_shared_volumes(self, mock_update_block_device_mapping):
"""Create shared volume."""
- self.vimconn.cinder = CopyingMock()
- self.vimconn.cinder.volumes.create.return_value.id = volume_id4
- shared_volume_data = {"size": 10, "name": "shared-volume"}
- self.vimconn.cinder.volumes.create.side_effect = [
- Volume("avaible", "multiattach", "shared-volume", volume_id4)
- ]
+
+ class MyVolume:
+ name = "my-shared-volume"
+ id = volume_id4
+ availability_zone = ["nova"]
+
+ self.vimconn.storage_availability_zone = ["nova"]
+ self.vimconn.cinder.volumes.create.return_value = MyVolume()
+ shared_volume_data = {"size": 10, "name": "my-shared-volume"}
result = self.vimconn.new_shared_volumes(shared_volume_data)
self.vimconn.cinder.volumes.create.assert_called_once_with(
- size=10, name="shared-volume", volume_type="multiattach"
+ size=10,
+ name="my-shared-volume",
+ volume_type="multiattach",
+ availability_zone=["nova"],
)
- self.assertEqual(result[0], "shared-volume")
+ self.assertEqual(result[0], "my-shared-volume")
self.assertEqual(result[1], volume_id4)
@patch.object(vimconnector, "update_block_device_mapping")
):
"""Create persistent root volume raise exception."""
self.vimconn.cinder.volumes.create.side_effect = Exception
- vm_av_zone = ["nova"]
+ storage_av_zone = ["nova"]
base_disk_index = ord("a")
disk = {"size": 10, "image_id": image_id}
block_device_mapping = {}
with self.assertRaises(Exception):
result = self.vimconn._prepare_persistent_root_volumes(
name,
- vm_av_zone,
+ storage_av_zone,
disk,
base_disk_index,
block_device_mapping,
):
"""Create persistent non-root volume raise exception."""
self.vimconn.cinder.volumes.create.side_effect = Exception
- vm_av_zone = ["nova"]
+ storage_av_zone = ["nova"]
base_disk_index = ord("b")
disk = {"size": 10}
block_device_mapping = {}
self.vimconn._prepare_non_root_persistent_volumes(
name,
disk,
- vm_av_zone,
+ storage_av_zone,
block_device_mapping,
base_disk_index,
existing_vim_volumes,
existing_vim_volumes = []
created_items = {}
block_device_mapping = {}
- vm_av_zone = ["nova"]
+ storage_av_zone = ["nova"]
mock_root_volumes.return_value = root_vol_id
mock_created_vol_availability.return_value = 10
name,
existing_vim_volumes,
created_items,
- vm_av_zone,
+ storage_av_zone,
block_device_mapping,
disk_list2,
)
self.assertEqual(mock_non_root_volumes.call_count, 1)
mock_root_volumes.assert_called_once_with(
name="basicvm",
- vm_av_zone=["nova"],
+ storage_av_zone=["nova"],
disk={"size": 10, "image_id": image_id},
base_disk_index=97,
block_device_mapping={},
mock_non_root_volumes.assert_called_once_with(
name="basicvm",
disk={"size": 20},
- vm_av_zone=["nova"],
+ storage_av_zone=["nova"],
base_disk_index=98,
block_device_mapping={},
existing_vim_volumes=[],
"""Timeout exceeded while waiting for disks."""
existing_vim_volumes = []
created_items = {}
- vm_av_zone = ["nova"]
+ storage_av_zone = ["nova"]
block_device_mapping = {}
mock_root_volumes.return_value = root_vol_id
name,
existing_vim_volumes,
created_items,
- vm_av_zone,
+ storage_av_zone,
block_device_mapping,
disk_list2,
)
self.assertEqual(mock_non_root_volumes.call_count, 1)
mock_root_volumes.assert_called_once_with(
name="basicvm",
- vm_av_zone=["nova"],
+ storage_av_zone=["nova"],
disk={"size": 10, "image_id": image_id},
base_disk_index=97,
block_device_mapping={},
mock_non_root_volumes.assert_called_once_with(
name="basicvm",
disk={"size": 20},
- vm_av_zone=["nova"],
+ storage_av_zone=["nova"],
base_disk_index=98,
block_device_mapping={},
existing_vim_volumes=[],
existing_vim_volumes = []
created_items = {}
block_device_mapping = {}
- vm_av_zone = ["nova"]
+ storage_av_zone = ["nova"]
mock_created_vol_availability.return_value = 2
mock_existing_vol_availability.return_value = 3
name,
existing_vim_volumes,
created_items,
- vm_av_zone,
+ storage_av_zone,
block_device_mapping,
disk_list,
)
"""Persistent root volumes preparation raises error."""
existing_vim_volumes = []
created_items = {}
- vm_av_zone = ["nova"]
+ storage_av_zone = ["nova"]
block_device_mapping = {}
mock_root_volumes.side_effect = Exception()
name,
existing_vim_volumes,
created_items,
- vm_av_zone,
+ storage_av_zone,
block_device_mapping,
disk_list2,
)
mock_existing_vol_availability.assert_not_called()
mock_root_volumes.assert_called_once_with(
name="basicvm",
- vm_av_zone=["nova"],
+ storage_av_zone=["nova"],
disk={"size": 10, "image_id": image_id},
base_disk_index=97,
block_device_mapping={},
"""Non-root volumes preparation raises error."""
existing_vim_volumes = []
created_items = {}
- vm_av_zone = ["nova"]
+ storage_av_zone = ["nova"]
block_device_mapping = {}
mock_root_volumes.return_value = root_vol_id
name,
existing_vim_volumes,
created_items,
- vm_av_zone,
+ storage_av_zone,
block_device_mapping,
disk_list2,
)
self.assertEqual(mock_non_root_volumes.call_count, 1)
mock_root_volumes.assert_called_once_with(
name="basicvm",
- vm_av_zone=["nova"],
+ storage_av_zone=["nova"],
disk={"size": 10, "image_id": image_id},
base_disk_index=97,
block_device_mapping={},
mock_non_root_volumes.assert_called_once_with(
name="basicvm",
disk={"size": 20},
- vm_av_zone=["nova"],
+ storage_av_zone=["nova"],
base_disk_index=98,
block_device_mapping={},
existing_vim_volumes=[],
name=name,
existing_vim_volumes=[],
created_items={},
- vm_av_zone="nova",
+ storage_av_zone="nova",
block_device_mapping={},
disk_list=disk_list2,
)
name=name,
existing_vim_volumes=[],
created_items={},
- vm_av_zone="nova",
+ storage_av_zone="nova",
block_device_mapping={},
disk_list=disk_list2,
)
name=name,
existing_vim_volumes=[],
created_items={},
- vm_av_zone="nova",
+ storage_av_zone="nova",
block_device_mapping={},
disk_list=disk_list2,
)
name=name,
existing_vim_volumes=[],
created_items={},
- vm_av_zone="nova",
+ storage_av_zone="nova",
block_device_mapping={},
disk_list=disk_list2,
)
},
)
- def test_delete_floating_ip_by_id_floating_ip_raises_nvexception(self):
+ def test_delete_floating_ip_by_id__delete_floating_ip_raises_client_exception__operation_is_successful(
+ self,
+ ):
"""netron delete floating ip raises nvExceptions.ClientException."""
created_items = {
f"floating_ip:{floating_network_vim_id}": True,
"Error deleting floating ip: ClientException: Unknown Error (HTTP Client exception occurred.)"
)
- def test_delete_floating_ip_by_id_floating_ip_raises_vimconnexception(self):
+ def test_delete_floating_ip_by_id__delete_floating_ip_raises_connection_error__operation_fails(
+ self,
+ ):
+ """netron delete floating ip raises nvExceptions.ClientException."""
+ created_items = {
+ f"floating_ip:{floating_network_vim_id}": True,
+ f"port:{port_id}": True,
+ }
+ k_id = floating_network_vim_id
+ k = f"floating_ip:{floating_network_vim_id}"
+ self.vimconn.neutron.delete_floatingip.side_effect = ConnectionError(
+ "Connection exception occurred."
+ )
+ with self.assertRaises(VimConnConnectionException):
+ self.vimconn._delete_floating_ip_by_id(k, k_id, created_items)
+ self.vimconn.neutron.delete_floatingip.assert_called_once_with(k_id)
+ self.assertEqual(
+ created_items,
+ {
+ f"floating_ip:{floating_network_vim_id}": True,
+ f"port:{port_id}": True,
+ },
+ )
+ self.vimconn.logger.error.assert_called_once_with(
+ "Error deleting floating ip: ConnectionError: Connection exception occurred."
+ )
+
+ def test_delete_floating_ip_by_id_floating_ip_raises_vimconn_not_found_exception__operation_is_successful(
+ self,
+ ):
"""netron delete floating ip raises VimConnNotFoundException."""
created_items = {
f"floating_ip:{floating_network_vim_id}": True,
)
self.assertEqual(created_items, expected_created_items)
- def test_delete_volumes_by_id_with_cinder_delete_volume_raise_exception(self):
+ def test_delete_volumes_by_id_with_cinder__delete_volume_raise_client_exception__exception_is_not_raised(
+ self,
+ ):
"""cinder delete volume raises exception."""
created_items = {
f"floating_ip:{floating_network_vim_id}": True,
k = f"volume:{volume_id}"
k_id = volume_id
self.vimconn.cinder.volumes.get.return_value.status = "available"
- self.vimconn.cinder.volumes.delete.side_effect = nvExceptions.ClientException(
- "Connection aborted."
+ self.vimconn.cinder.volumes.delete.side_effect = cExceptions.ClientException(
+ 403, "Connection aborted."
)
result = self.vimconn._delete_volumes_by_id_wth_cinder(
k, k_id, volumes_to_hold, created_items
self.vimconn.cinder.volumes.get.assert_called_once_with(k_id)
self.vimconn.cinder.volumes.delete.assert_called_once_with(k_id)
self.vimconn.logger.error.assert_called_once_with(
- "Error deleting volume: ClientException: Unknown Error (HTTP Connection aborted.)"
+ "Error deleting volume: ClientException: Connection aborted. (HTTP 403)"
+ )
+ self.assertEqual(created_items, expected_created_items)
+
+ def test_delete_volumes_by_id_with_cinder__delete_volume_raise_connection_exception__exception_is_raised(
+ self,
+ ):
+ """cinder delete volume raises exception."""
+ created_items = {
+ f"floating_ip:{floating_network_vim_id}": True,
+ f"volume:{volume_id2}": True,
+ f"volume:{volume_id}": True,
+ f"port:{port_id}": None,
+ }
+ expected_created_items = {
+ f"floating_ip:{floating_network_vim_id}": True,
+ f"volume:{volume_id2}": True,
+ f"volume:{volume_id}": True,
+ f"port:{port_id}": None,
+ }
+ volumes_to_hold = []
+ k = f"volume:{volume_id}"
+ k_id = volume_id
+ self.vimconn.cinder.volumes.get.return_value.status = "available"
+ self.vimconn.cinder.volumes.delete.side_effect = cExceptions.ConnectionError(
+ "Connection failed."
+ )
+ with self.assertRaises(VimConnConnectionException):
+ result = self.vimconn._delete_volumes_by_id_wth_cinder(
+ k, k_id, volumes_to_hold, created_items
+ )
+ self.assertEqual(result, None)
+ self.vimconn.cinder.volumes.get.assert_called_once_with(k_id)
+ self.vimconn.cinder.volumes.delete.assert_called_once_with(k_id)
+ self.vimconn.logger.error.assert_called_once_with(
+ "Error deleting volume: ConnectionError: Connection failed."
)
self.assertEqual(created_items, expected_created_items)
result = self.vimconn._delete_volumes_by_id_wth_cinder(
k, k_id, volumes_to_hold, created_items
)
- self.assertEqual(result, None)
+ self.assertEqual(result, False)
self.vimconn.cinder.volumes.get.assert_not_called()
self.vimconn.cinder.volumes.delete.assert_not_called()
self.vimconn.logger.error.assert_not_called()
def test_delete_ports_by_id_by_neutron(self):
"""neutron delete ports."""
k_id = port_id
- self.vimconn.neutron.list_ports.return_value = {
- "ports": [{"id": port_id}, {"id": port2_id}]
- }
-
self.vimconn._delete_ports_by_id_wth_neutron(k_id)
- self.vimconn.neutron.list_ports.assert_called_once()
self.vimconn.neutron.delete_port.assert_called_once_with(k_id)
self.vimconn.logger.error.assert_not_called()
- def test_delete_ports_by_id_by_neutron_id_not_in_port_list(self):
- """port id not in the port list."""
- k_id = volume_id
- self.vimconn.neutron.list_ports.return_value = {
- "ports": [{"id": port_id}, {"id": port2_id}]
- }
-
- self.vimconn._delete_ports_by_id_wth_neutron(k_id)
- self.vimconn.neutron.list_ports.assert_called_once()
- self.vimconn.neutron.delete_port.assert_not_called()
- self.vimconn.logger.error.assert_not_called()
-
- def test_delete_ports_by_id_by_neutron_list_port_raise_exception(self):
- """neutron list port raises exception."""
- k_id = port_id
- self.vimconn.neutron.list_ports.side_effect = nvExceptions.ClientException(
- "Connection aborted."
- )
- self.vimconn._delete_ports_by_id_wth_neutron(k_id)
- self.vimconn.neutron.list_ports.assert_called_once()
- self.vimconn.neutron.delete_port.assert_not_called()
- self.vimconn.logger.error.assert_called_once_with(
- "Error deleting port: ClientException: Unknown Error (HTTP Connection aborted.)"
- )
-
def test_delete_ports_by_id_by_neutron_delete_port_raise_exception(self):
"""neutron delete port raises exception."""
k_id = port_id
- self.vimconn.neutron.list_ports.return_value = {
- "ports": [{"id": port_id}, {"id": port2_id}]
- }
self.vimconn.neutron.delete_port.side_effect = nvExceptions.ClientException(
"Connection aborted."
)
self.vimconn._delete_ports_by_id_wth_neutron(k_id)
- self.vimconn.neutron.list_ports.assert_called_once()
self.vimconn.neutron.delete_port.assert_called_once_with(k_id)
self.vimconn.logger.error.assert_called_once_with(
"Error deleting port: ClientException: Unknown Error (HTTP Connection aborted.)"
@patch.object(vimconnector, "_get_item_name_id")
@patch.object(vimconnector, "_delete_volumes_by_id_wth_cinder")
@patch.object(vimconnector, "_delete_floating_ip_by_id")
- def test_delete_created_items_delete_vol_raises(
+ def test_delete_created_items__delete_vol_raises_connection_error__operation_fails(
self,
mock_delete_floating_ip_by_id,
mock_delete_volumes_by_id_wth_cinder,
("floating_ip", f"{floating_network_vim_id}"),
("volume", f"{volume_id}"),
]
- mock_delete_volumes_by_id_wth_cinder.side_effect = ConnectionError(
- "Connection failed."
+ mock_delete_volumes_by_id_wth_cinder.side_effect = (
+ neExceptions.ConnectionFailed("Connection failed.")
)
volumes_to_hold = []
keep_waiting = False
- result = self.vimconn._delete_created_items(
- created_items, volumes_to_hold, keep_waiting
- )
- self.assertEqual(result, False)
+ with self.assertRaises(VimConnConnectionException):
+ result = self.vimconn._delete_created_items(
+ created_items, volumes_to_hold, keep_waiting
+ )
+ self.assertEqual(result, None)
self.assertEqual(mock_get_item_name_id.call_count, 2)
mock_delete_volumes_by_id_wth_cinder.assert_called_once_with(
f"volume:{volume_id}", f"{volume_id}", [], created_items
@patch.object(vimconnector, "_get_item_name_id")
@patch.object(vimconnector, "_delete_volumes_by_id_wth_cinder")
@patch.object(vimconnector, "_delete_floating_ip_by_id")
- def test_delete_created_items_delete_fip_raises(
+ def test_delete_created_items__delete_fip_raises_connection_error__operation_fails(
self,
mock_delete_floating_ip_by_id,
mock_delete_volumes_by_id_wth_cinder,
)
volumes_to_hold = []
keep_waiting = True
- result = self.vimconn._delete_created_items(
- created_items, volumes_to_hold, keep_waiting
- )
- self.assertEqual(result, True)
- self.assertEqual(mock_get_item_name_id.call_count, 2)
- mock_delete_volumes_by_id_wth_cinder.assert_called_once_with(
- f"volume:{volume_id}", f"{volume_id}", [], created_items
- )
+ with self.assertRaises(VimConnConnectionException):
+ result = self.vimconn._delete_created_items(
+ created_items, volumes_to_hold, keep_waiting
+ )
+ self.assertEqual(result, None)
+ self.assertEqual(mock_get_item_name_id.call_count, 1)
+ mock_delete_volumes_by_id_wth_cinder.assert_not_called()
mock_delete_floating_ip_by_id.assert_called_once_with(
f"floating_ip:{floating_network_vim_id}",
f"{floating_network_vim_id}",
@patch.object(vimconnector, "_get_item_name_id")
@patch.object(vimconnector, "_delete_volumes_by_id_wth_cinder")
@patch.object(vimconnector, "_delete_floating_ip_by_id")
- def test_delete_created_items_get_item_name_raises(
+ def test_delete_created_items_get_item_name_raises_type_error__operation_fails(
self,
mock_delete_floating_ip_by_id,
mock_delete_volumes_by_id_wth_cinder,
]
volumes_to_hold = []
keep_waiting = False
- result = self.vimconn._delete_created_items(
- created_items, volumes_to_hold, keep_waiting
- )
- self.assertEqual(result, False)
- self.assertEqual(mock_get_item_name_id.call_count, 2)
+ with self.assertRaises(VimConnException):
+ result = self.vimconn._delete_created_items(
+ created_items, volumes_to_hold, keep_waiting
+ )
+ self.assertEqual(result, None)
+ self.assertEqual(mock_get_item_name_id.call_count, 1)
mock_delete_volumes_by_id_wth_cinder.assert_not_called()
mock_delete_floating_ip_by_id.assert_not_called()
_call_logger = self.vimconn.logger.error.call_args_list
self.assertEqual(_call_logger[0][0], ("Error deleting 3: Invalid Type",))
- self.assertEqual(
- _call_logger[1][0],
- (f"Error deleting volume{volume_id}: Invalid attribute",),
- )
@patch.object(vimconnector, "_get_item_name_id")
@patch.object(vimconnector, "_delete_volumes_by_id_wth_cinder")
@patch("time.sleep")
@patch.object(vimconnector, "_extract_items_wth_keep_flag_from_created_items")
- @patch.object(vimconnector, "_format_exception")
@patch.object(vimconnector, "_reload_connection")
@patch.object(vimconnector, "_delete_vm_ports_attached_to_network")
@patch.object(vimconnector, "_delete_created_items")
- def test_delete_vminstance_extract_items_wth_keep_raises(
+ def test_delete_vminstance__extract_items_wth_keep_raises_attributeerror__raise_vimconnexception(
self,
mock_delete_created_items,
mock_delete_vm_ports_attached_to_network,
mock_reload_connection,
- mock_format_exception,
mock_extract_items_wth_keep_flag_from_created_items,
mock_sleep,
):
mock_extract_items_wth_keep_flag_from_created_items.side_effect = AttributeError
volumes_to_hold = []
mock_delete_created_items.return_value = False
- with self.assertRaises(AttributeError):
+ with self.assertRaises(VimConnException):
self.vimconn.delete_vminstance(
vm_id, initial_created_items, volumes_to_hold
)
self.vimconn.nova.servers.delete.assert_not_called()
mock_delete_created_items.assert_not_called()
mock_sleep.assert_not_called()
- mock_format_exception.assert_not_called()
mock_extract_items_wth_keep_flag_from_created_items.assert_called_once_with(
initial_created_items
)
@patch.object(vimconnector, "_reload_connection")
@patch.object(vimconnector, "_delete_vm_ports_attached_to_network")
@patch.object(vimconnector, "_delete_created_items")
- def test_delete_vminstance_delete_created_items_raises(
+ def test_delete_vminstance__delete_created_items_returns_true__delete_created_items_called_several_times(
self,
mock_delete_created_items,
mock_delete_vm_ports_attached_to_network,
mock_extract_items_wth_keep_flag_from_created_items.return_value = created_items
mock_sleep = MagicMock()
volumes_to_hold = []
- err = ConnectionError("ClientException occurred.")
- mock_delete_created_items.side_effect = err
- with self.assertRaises(ConnectionError) as err:
- self.vimconn.delete_vminstance(vm_id, created_items, volumes_to_hold)
- self.assertEqual(str(err), "ClientException occurred.")
+ mock_delete_created_items.side_effect = [True, False]
+ self.vimconn.delete_vminstance(vm_id, created_items, volumes_to_hold)
mock_reload_connection.assert_called_once()
mock_delete_vm_ports_attached_to_network.assert_called_once_with(created_items)
self.vimconn.nova.servers.delete.assert_called_once_with(vm_id)
- mock_delete_created_items.assert_called_once()
+ self.assertEqual(mock_delete_created_items.call_count, 2)
mock_sleep.assert_not_called()
mock_extract_items_wth_keep_flag_from_created_items.assert_called_once_with(
created_items
@patch("time.sleep")
@patch.object(vimconnector, "_extract_items_wth_keep_flag_from_created_items")
- @patch.object(vimconnector, "_format_exception")
@patch.object(vimconnector, "_reload_connection")
@patch.object(vimconnector, "_delete_vm_ports_attached_to_network")
@patch.object(vimconnector, "_delete_created_items")
- def test_delete_vminstance_delete_vm_ports_raises(
+ def test_delete_vminstance__delete_vm_ports_raises_connection_error__raise_vimconnconnectionexception(
self,
mock_delete_created_items,
mock_delete_vm_ports_attached_to_network,
mock_reload_connection,
- mock_format_exception,
mock_extract_items_wth_keep_flag_from_created_items,
mock_sleep,
):
volumes_to_hold = [f"{volume_id}", f"{volume_id2}"]
err = ConnectionError("ClientException occurred.")
mock_delete_vm_ports_attached_to_network.side_effect = err
- mock_delete_created_items.side_effect = err
- with self.assertRaises(ConnectionError) as err:
+ mock_delete_created_items.return_value = False
+ with self.assertRaises(VimConnConnectionException):
self.vimconn.delete_vminstance(vm_id, created_items, volumes_to_hold)
- self.assertEqual(str(err), "ClientException occurred.")
mock_reload_connection.assert_called_once()
mock_delete_vm_ports_attached_to_network.assert_called_once_with(created_items)
self.vimconn.nova.servers.delete.assert_not_called()
@patch("time.sleep")
@patch.object(vimconnector, "_extract_items_wth_keep_flag_from_created_items")
- @patch.object(vimconnector, "_format_exception")
@patch.object(vimconnector, "_reload_connection")
@patch.object(vimconnector, "_delete_vm_ports_attached_to_network")
@patch.object(vimconnector, "_delete_created_items")
- def test_delete_vminstance_nova_server_delete_raises(
+ def test_delete_vminstance__nova_server_delete_raises_clientexception__raise_vimconn_unexpected_response(
self,
mock_delete_created_items,
mock_delete_vm_ports_attached_to_network,
mock_reload_connection,
- mock_format_exception,
mock_extract_items_wth_keep_flag_from_created_items,
mock_sleep,
):
created_items = deepcopy(created_items_all_true)
mock_extract_items_wth_keep_flag_from_created_items.return_value = created_items
volumes_to_hold = [f"{volume_id}", f"{volume_id2}"]
- err = VimConnConnectionException("ClientException occurred.")
+ err = nvExceptions.ClientException("ClientException occurred.")
self.vimconn.nova.servers.delete.side_effect = err
mock_delete_created_items.side_effect = err
- with self.assertRaises(VimConnConnectionException) as err:
+ with self.assertRaises(VimConnUnexpectedResponse):
self.vimconn.delete_vminstance(vm_id, created_items, volumes_to_hold)
- self.assertEqual(str(err), "ClientException occurred.")
mock_reload_connection.assert_called_once()
mock_delete_vm_ports_attached_to_network.assert_called_once_with(created_items)
self.vimconn.nova.servers.delete.assert_called_once_with(vm_id)
@patch("time.sleep")
@patch.object(vimconnector, "_extract_items_wth_keep_flag_from_created_items")
- @patch.object(vimconnector, "_format_exception")
@patch.object(vimconnector, "_reload_connection")
@patch.object(vimconnector, "_delete_vm_ports_attached_to_network")
@patch.object(vimconnector, "_delete_created_items")
- def test_delete_vminstance_reload_connection_raises(
+ def test_delete_vminstance__reload_connection_raises_connection_error__raises_vimconnconnection_exception(
self,
mock_delete_created_items,
mock_delete_vm_ports_attached_to_network,
mock_reload_connection,
- mock_format_exception,
mock_extract_items_wth_keep_flag_from_created_items,
mock_sleep,
):
err = ConnectionError("ClientException occurred.")
mock_delete_created_items.return_value = False
mock_reload_connection.side_effect = err
- with self.assertRaises(ConnectionError) as err:
+ with self.assertRaises(VimConnConnectionException):
self.vimconn.delete_vminstance(vm_id, created_items, volumes_to_hold)
- self.assertEqual(str(err), "ClientException occurred.")
mock_reload_connection.assert_called_once()
mock_delete_vm_ports_attached_to_network.assert_not_called()
self.vimconn.nova.servers.delete.assert_not_called()
projects / osm / RO.git / blobdiff