Fix irrelevant unit tests after vMotion

Some unit tests became irrelevant or wrong and needed to be fixed
after vMotion handling implementation

Change-Id: Ib2d60b0cc1a5c658b3ad87ae29f1e3d1a603dcdc
Partial-Bug: #1776434

cvm/clients.py

@@ -175,7 +175,7 @@ def set_vlan_id(self, dvs_name, key, vlan_id):
         except StopIteration:
             return
         dv_port_spec = make_dv_port_spec(dv_port, vlan_id)
-        logger.info('Setting VLAN ID of port %s to %d' % (key, vlan_id))
+        logger.info('Setting VLAN ID of port %s to %d', key, vlan_id)
         dvs.ReconfigureDVPort_Task(port=[dv_port_spec])
 
     def restore_vlan_id(self, dvs_name, key):
@@ -214,6 +214,7 @@ def __init__(self, vnc_cfg):
         self.id_perms.set_enable(True)
 
     def delete_vm(self, vnc_vm):
+        # TODO: Remove code duplication -- see VirtualMachineService._can_delete_from_vnc
         try:
             existing_vm = self.read_vm(vnc_vm.uuid)
             vrouter_uuid = next(pair.value
@@ -224,8 +225,8 @@ def delete_vm(self, vnc_vm):
                 self.vnc_lib.virtual_machine_delete(id=vnc_vm.uuid)
                 logger.info('Virtual Machine removed: %s', vnc_vm.name)
             else:
-                logger.error('Virtual Machine %s is managed by vRouter %s and cannot be deleted from VNC.' %
-                             (vnc_vm.name, vrouter_uuid))
+                logger.error('Virtual Machine %s is managed by vRouter %s and cannot be deleted from VNC.',
+                             vnc_vm.name, vrouter_uuid)
         except NoIdError:
             logger.error('Virtual Machine not found: %s', vnc_vm.name)
 
@@ -287,7 +288,7 @@ def read_vmi(self, uuid):
         try:
             return self.vnc_lib.virtual_machine_interface_read(id=uuid)
         except NoIdError:
-            logger.error('Virtual Machine Interface not found %s' % uuid)
+            logger.error('Virtual Machine Interface not found %s', uuid)
             return None
 
     def get_vns_by_project(self, project):
@@ -357,7 +358,7 @@ def create_and_read_instance_ip(self, instance_ip):
             # TODO: Refactor this
         except NoIdError:
             self.vnc_lib.instance_ip_create(instance_ip)
-            logger.debug("Created instanceIP: " + instance_ip.name)
+            logger.debug("Created instanceIP: %s", instance_ip.name)
         return self._read_instance_ip(instance_ip.uuid)
 
     def delete_instance_ip(self, uuid):
@@ -440,17 +441,17 @@ def add_port(self, vmi_model):
                 vm_project_id=vmi_model.vn_model.vnc_vn.parent_uuid,
             )
         except Exception, e:
-            logger.error('There was a problem with vRouter API Client: %s' % e)
+            logger.error('There was a problem with vRouter API Client: %s', e)
 
     def delete_port(self, vmi_uuid):
         """ Delete port from VRouter Agent. """
         try:
             self.vrouter_api.delete_port(vmi_uuid)
         except Exception, e:
-            logger.error('There was a problem with vRouter API Client: %s' % e)
+            logger.error('There was a problem with vRouter API Client: %s', e)
 
     def enable_port(self, vmi_uuid):
         try:
             self.vrouter_api.enable_port(vmi_uuid)
         except Exception, e:
-            logger.error('There was a problem with vRouter API Client: %s' % e)
+            logger.error('There was a problem with vRouter API Client: %s', e)

cvm/services.py

@@ -82,8 +82,8 @@ def _can_delete_from_vnc(self, vm_model):
         if any([pair.key == 'vrouter-uuid' and pair.value == vrouter_uuid
                 for pair in existing_vm.get_annotations().key_value_pair]):
             return True
-        logger.error('Virtual Machine %s is managed by vRouter %s and cannot be deleted from VNC.' %
-                     (vm_model.name, vrouter_uuid))
+        logger.error('Virtual Machine %s is managed by vRouter %s and cannot be deleted from VNC.',
+                     vm_model.name, vrouter_uuid)
         return False
 
     def set_tools_running_status(self, vmware_vm, value):
@@ -175,7 +175,6 @@ def _create_or_update(self, vmi_model):
         self._vnc_api_client.update_or_create_vmi(vmi_model.to_vnc())
         vmi_model.construct_instance_ip()
         if vmi_model.vnc_instance_ip:
-            self._vnc_api_client.delete_instance_ip(uuid=vmi_model.vnc_instance_ip.uuid)
             instance_ip = self._vnc_api_client.create_and_read_instance_ip(vmi_model.vnc_instance_ip)
             vmi_model.vnc_instance_ip = instance_ip
         self._add_or_update_vrouter_port(vmi_model)
@@ -220,6 +219,7 @@ def _delete_from_vnc(self, vmi_model):
         if vmi_model.vnc_instance_ip:
             self._vnc_api_client.delete_instance_ip(vmi_model.vnc_instance_ip.uuid)
         self._vnc_api_client.delete_vmi(vmi_model.uuid)
+        vmi_model.vnc_vmi = None
 
     def _restore_vlan_id(self, vmi_model):
         with self._vcenter_api_client:
@@ -234,8 +234,8 @@ def _can_delete_from_vnc(self, vmi_model):
         if any([pair.key == 'vrouter-uuid' and pair.value == vrouter_uuid
                 for pair in existing_vmi.get_annotations().key_value_pair]):
             return True
-        logger.error('Virtual Machine Interface %s is managed by vRouter %s and cannot be deleted from VNC.' %
-                     (vmi_model.vnc_vmi.display_name, vrouter_uuid))
+        logger.error('Virtual Machine Interface %s is managed by vRouter %s and cannot be deleted from VNC.',
+                     vmi_model.vnc_vmi.display_name, vrouter_uuid)
         return False
 
     def _delete_vrouter_port(self, vmi_model):

tests/test_clients.py

@@ -127,5 +127,5 @@ def test_get_all_vms(self):
 
         all_vms = self.vnc_client.get_all_vms()
 
-        self.vnc_lib.virtual_machine_read.assert_called_once_with(['5027a82e-fbc7-0898-b64c-4bf9f5b9d07c'])
+        self.vnc_lib.virtual_machine_read.assert_called_once_with(id=u'5027a82e-fbc7-0898-b64c-4bf9f5b9d07c')
         self.assertEqual([vnc_vm], all_vms)

tests/test_controllers.py

@@ -4,7 +4,8 @@
 from mock import Mock, patch
 from pyVmomi import vim, vmodl  # pylint: disable=no-name-in-module
 
-from cvm.controllers import VmRenamedHandler, VmwareController
+from cvm.controllers import (VmRemovedHandler, VmRenamedHandler,
+                             VmwareController)
 
 logging.disable(logging.CRITICAL)
 
@@ -25,8 +26,10 @@ def setUp(self):
         self.vmi_service = Mock()
 
         vm_renamed_handler = VmRenamedHandler(self.vm_service, self.vmi_service)
+        vm_removed_handler = VmRemovedHandler(self.vm_service, self.vmi_service)
+        handlers = [vm_renamed_handler, vm_removed_handler]
         self.vmware_controller = VmwareController(self.vm_service, None, self.vmi_service,
-                                                  [vm_renamed_handler])
+                                                  handlers)
 
     @patch.object(VmwareController, '_handle_change')
     def test_handle_update_no_fltr_set(self, mocked_handle_change):

tests/test_events.py

@@ -114,10 +114,10 @@ def vm_created_update(vmware_vm_1):
 
 
 @pytest.fixture()
-def vm_renamed_update(vmware_vm_1):
+def vm_renamed_update():
     event = Mock(spec=vim.event.VmRenamedEvent())
-    vmware_vm_1.name = 'VM1-renamed'
-    event.vm.vm = vmware_vm_1
+    event.oldName = 'VM1'
+    event.newName = 'VM1-renamed'
     return wrap_into_update_set(event)
 
 

tests/test_models.py

@@ -113,14 +113,15 @@ def test_init(self):
     def test_to_vnc(self):
         vm_model = VirtualMachineModel(self.vmware_vm, self.vm_properties)
         vm_model.vm_properties['config.instanceUuid'] = 'd376b6b4-943d-4599-862f-d852fd6ba425'
-        vm_model.vrouter_uuid = '192.168.0.10'
+        vm_model.vrouter_uuid = 'vrouter_uuid'
 
         vnc_vm = vm_model.vnc_vm
 
-        self.assertEqual(vnc_vm.name, vm_model.uuid)
-        self.assertEqual(vnc_vm.uuid, vm_model.uuid)
-        self.assertEqual(vnc_vm.display_name, vm_model.vrouter_uuid)
-        self.assertEqual(vnc_vm.fq_name, [vm_model.uuid])
+        self.assertEqual(vm_model.uuid, vnc_vm.name)
+        self.assertEqual(vm_model.uuid, vnc_vm.uuid)
+        self.assertEqual([vm_model.uuid], vnc_vm.fq_name)
+        vrouter_annotation = vnc_vm.get_annotations().get_key_value_pair()[0]
+        self.assertEqual('vrouter_uuid', vrouter_annotation.value)
 
     def test_update(self):
         vm_model = VirtualMachineModel(self.vmware_vm, self.vm_properties)

tests/test_services.py

@@ -61,7 +61,9 @@ def test_destroy_property_filter(self):
         vm_model = Mock()
         self.database.get_vm_model_by_name.return_value = vm_model
 
-        self.vm_service.remove_vm('VM')
+        with patch('cvm.services.VirtualMachineService._can_delete_from_vnc') as can_delete:
+            can_delete.return_value = True
+            self.vm_service.remove_vm('VM')
 
         vm_model.destroy_property_filter.assert_called_once()
 
@@ -111,10 +113,12 @@ def test_remove_vm(self):
         vm_model = Mock(uuid='d376b6b4-943d-4599-862f-d852fd6ba425')
         self.database.get_vm_model_by_name.return_value = vm_model
 
-        self.vm_service.remove_vm('VM')
+        with patch('cvm.services.VirtualMachineService._can_delete_from_vnc') as can_delete:
+            can_delete.return_value = True
+            self.vm_service.remove_vm('VM')
 
         self.database.delete_vm_model.assert_called_once_with(vm_model.uuid)
-        self.vnc_client.delete_vm.assert_called_once_with(vm_model.uuid)
+        self.vnc_client.delete_vm.assert_called_once_with(vm_model.vnc_vm)
 
     def test_remove_no_vm(self):
         """ Remove VM should do nothing when VM doesn't exist in database. """
@@ -139,13 +143,13 @@ def test_set_tools_running_status(self):
     def test_rename_vm(self):
         vm_model = Mock()
         vm_model.configure_mock(name='VM')
-        self.database.get_vm_model_by_uuid.return_value = vm_model
+        self.database.get_vm_model_by_name.return_value = vm_model
         vmware_vm = Mock()
         vmware_vm.configure_mock(name='VM-renamed')
 
-        self.vm_service.rename_vm(vmware_vm)
+        self.vm_service.rename_vm('VM', 'VM-renamed')
 
-        vm_model.rename.assert_called_once_with(vmware_vm)
+        vm_model.rename.assert_called_once_with('VM-renamed')
         self.vnc_client.update_or_create_vm.assert_called_once()
         self.database.save.assert_called_once_with(vm_model)
 
@@ -280,10 +284,11 @@ def test_remove_vmis_for_vm_model(self):
         self.database.save(vmi_model)
         self.database.save(self.vm_model)
 
-        with patch.object(self.database, 'delete_vmi_model') as database_del_mock:
+        with patch('cvm.services.VirtualMachineInterfaceService._can_delete_from_vnc') as can_delete:
+            can_delete.return_value = True
             self.vmi_service.remove_vmis_for_vm_model(self.vm_model.name)
 
-        database_del_mock.assert_called_once_with(vmi_model.uuid)
+        self.assertNotIn(vmi_model, self.database.get_all_vmi_models())
         self.vnc_client.delete_vmi.assert_called_once_with(vmi_model.uuid)
 
     def test_remove_vmis_no_vm_model(self):
@@ -305,7 +310,7 @@ def test_rename_vmis(self):
         self.vm_model.update(*create_vmware_vm_mock(name='VM-renamed'))
         self.database.save(self.vm_model)
 
-        self.vmi_service.rename_vmis(self.vm_model.vmware_vm)
+        self.vmi_service.rename_vmis('VM-renamed')
 
         self.assertEqual('vmi-VM Portgroup-VM-renamed', vmi_model.display_name)
         self.assertEqual(0, self.vnc_client.create_and_read_instance_ip.call_count)