def test_virtual_machine_create(self):
        test_utils.create_test_project('fake-domain:fake-project')
        test_utils.create_test_security_group(
            'fake-domain:fake-project:default')
        test_utils.create_test_virtual_network(
            'fake-domain:fake-project:left-vn')
        test_utils.create_test_virtual_network(
            'fake-domain:fake-project:right-vn')

        st = test_utils.create_test_st(name='vm-template',
                                       virt_type='virtual-machine',
                                       intf_list=[['management', False],
                                                  ['left', True],
                                                  ['right', False]])
        si = test_utils.create_test_si(name='vm-instance',
                                       count=2,
                                       intf_list=['', 'left-vn', 'right-vn'])

        def nova_oper(resource, oper, proj_name, **kwargs):
            if resource == 'servers' and oper == 'create':
                nova_vm = test_utils.FakeNovaServer('fake-vm-uuid',
                                                    kwargs['name'])
                return nova_vm
            else:
                return mock.MagicMock()

        self.nova_mock.oper = nova_oper

        self.vm_manager.create_service(st, si)
        self.mocked_vnc.virtual_machine_create.assert_any_call(
            test_utils.VMObjMatcher(1))
        self.mocked_vnc.virtual_machine_create.assert_any_call(
            test_utils.VMObjMatcher(2))
        self.assertTrue(si.availability_zone, 'default-availability-zone')
Пример #2
0
    def test_snat_instance_create(self):
        test_utils.create_test_project('fake-domain:fake-project')
        test_utils.create_test_virtual_network(
            'fake-domain:fake-project:public-vn')
        test_utils.create_test_virtual_network(
            'fake-domain:fake-project:fake-vn-uuid')
        test_utils.create_test_security_group(
            'fake-domain:fake-project:default')
        test_utils.create_test_virtual_router('fake-virtual-router')

        st = test_utils.create_test_st(name='snat-template',
                                       virt_type='network-namespace',
                                       intf_list=[['right', True],
                                                  ['left', True]])
        si = test_utils.create_test_si(name='snat-instance',
                                       count=2,
                                       intf_list=['public-vn', 'fake-vn-uuid'])

        self.netns_manager.create_service(st, si)
        self.mocked_vnc.virtual_machine_create.assert_any_call(
            test_utils.VMObjMatcher(1))
        self.mocked_vnc.virtual_machine_create.assert_any_call(
            test_utils.VMObjMatcher(2))
        self.assertEqual(si.vn_info[1]['net-id'],
                         'fake-domain:fake-project:fake-vn-uuid')
Пример #3
0
    def test_snat_instance_delete(self):
        def create_fake_virtual_machine(fq_name_str):
            vm_obj = {}
            vm_obj['fq_name'] = fq_name_str.split(':')
            vm_obj['uuid'] = fq_name_str
            vm_obj['display_name'] = fq_name_str
            vm = VirtualMachineSM.locate(vm_obj['uuid'], vm_obj)
            vm.proj_fq_name = ['fake-domain', 'fake-project']
            vm.virtual_machine_interfaces = set(
                ['fake-vmi-uuid1', 'fake-vmi-uuid2', 'fake-vmi-uuid3'])
            vm.virtual_router = 'fake-vr-uuid'
            return vm

        mocked_vr = mock.MagicMock()
        mocked_vr.uuid = 'fake-vr-uuid'

        self.netns_manager._vnc_lib.virtual_router_read.\
            return_value = mocked_vr

        vm = create_fake_virtual_machine('fake-vm-uuid')
        self.netns_manager.delete_service(vm)

        self.netns_manager._vnc_lib.virtual_machine_delete\
            .assert_called_with(id='fake-vm-uuid')
        mocked_vr.del_virtual_machine.assert_called_with(
            test_utils.VMObjMatcher('fake-vm-uuid', True))
Пример #4
0
    def test_vrouter_instance_create(self):
        test_utils.create_test_project('fake-domain:fake-project')
        test_utils.create_test_security_group(
            'fake-domain:fake-project:default')
        test_utils.create_test_virtual_network(
            'fake-domain:fake-project:mgmt-vn')
        test_utils.create_test_virtual_network(
            'fake-domain:fake-project:left-vn')
        test_utils.create_test_virtual_network(
            'fake-domain:fake-project:right-vn')

        st = test_utils.create_test_st(name='vrouter-template',
                                       virt_type='vrouter-instance',
                                       intf_list=[['management', False],
                                                  ['left', False],
                                                  ['right', False]])
        si = test_utils.create_test_si(
            name='vr-instance',
            count=1,
            vr_id='fake-vr-id',
            intf_list=['mgmt-vn', 'left-vn', 'right-vn'])

        self.vrouter_manager.create_service(st, si)
        self.mocked_vnc.virtual_machine_create.assert_any_call(
            test_utils.VMObjMatcher(1))
        self.mocked_vnc.virtual_router_update.assert_any_call(
            test_utils.VRObjMatcher(['fake-vm-uuid']))
Пример #5
0
    def test_svc_monitor_upgrade(self):
        def nova_oper(resource, oper, proj_name, **kwargs):
            if resource == 'servers' and oper == 'get':
                nova_vm = test_utils.FakeNovaServer('fake-vm',
                    'default-domain__fake-project__fake-instance__1')
                return nova_vm
            else:
                return mock.MagicMock()
        self._svc_monitor._nova_client = mock.MagicMock()
        self._svc_monitor._nova_client.oper = nova_oper

        st_obj = self.add_st('fake-template', 'fake-template')
        st = config_db.ServiceTemplateSM.get('fake-template')
        st.virtualization_type = 'virtual-machine'
        si_obj = self.add_si('fake-instance', 'fake-instance', st_obj)
        vm_obj = self.add_vm('fake-vm', 'fake-vm', si_obj)
        self._svc_monitor.upgrade()
        self.vnc_mock.virtual_machine_update.assert_any_call(test_utils.VMObjMatcher(1))