def _attach_pci_device(self, vmid, dev_info): self._validate_pci_passthrough_env() dom = VMModel.get_vm(vmid, self.conn) # Due to libvirt limitation, we don't support live assigne device to # vfio driver. driver = ('vfio' if DOM_STATE_MAP[dom.info()[0]] == "shutoff" and self.caps.kernel_vfio else 'kvm') # on powerkvm systems it must be vfio driver. distro, _, _ = platform.linux_distribution() if distro == 'IBM_PowerKVM': driver = 'vfio' # Attach all PCI devices in the same IOMMU group dev_model = DeviceModel(conn=self.conn) devs_model = DevicesModel(conn=self.conn) affected_names = devs_model.get_list( _passthrough_affected_by=dev_info['name']) passthrough_names = devs_model.get_list(_cap='pci', _passthrough='true') group_names = list(set(affected_names) & set(passthrough_names)) pci_infos = [dev_model.lookup(dev_name) for dev_name in group_names] pci_infos.append(dev_info) # all devices in the group that is going to be attached to the vm # must be detached from the host first with RollbackContext() as rollback: for pci_info in pci_infos: try: dev = self.conn.get().nodeDeviceLookupByName( pci_info['name']) dev.dettach() except Exception: raise OperationFailed('KCHVMHDEV0005E', {'name': pci_info['name']}) else: rollback.prependDefer(dev.reAttach) rollback.commitAll() device_flags = get_vm_config_flag(dom, mode='all') with RollbackContext() as rollback: for pci_info in pci_infos: pci_info['detach_driver'] = driver xmlstr = self._get_pci_device_xml(pci_info) try: dom.attachDeviceFlags(xmlstr, device_flags) except libvirt.libvirtError: wok_log.error( 'Failed to attach host device %s to VM %s: \n%s', pci_info['name'], vmid, xmlstr) raise rollback.prependDefer(dom.detachDeviceFlags, xmlstr, device_flags) rollback.commitAll() return dev_info['name']
def create(self, params): params = self._validate_create_params(params) username = params['name'] passwd = params['password'] profile = params['profile'] groupname = params['group'] no_login = params['no_login'] with RollbackContext() as rollback: adm = libuser.admin() if groupname: group_obj = adm.lookupGroupByName(groupname) if group_obj: group_id = group_obj.get('pw_gid')[0] else: group_id = create_group(groupname) rollback.prependDefer(delete_group, groupname) else: group_id = create_group(username) rollback.prependDefer(delete_group, username) create_user(username, passwd, group_id, no_login=no_login) rollback.prependDefer(delete_user, username) if profile == 'virtuser': self._add_user_to_kvm_group(username) if profile == 'admin': self._add_user_to_sudoers(username) rollback.commitAll() return username
def test_debugreport_download(self): req = json.dumps({'name': 'test_rest_report1'}) with RollbackContext() as rollback: resp = request('/plugins/gingerbase/debugreports', req, 'POST') self.assertEquals(202, resp.status) task = json.loads(resp.read()) # make sure the debugreport doesn't exist until the # the task is finished wait_task(self._task_lookup, task['id'], 20) rollback.prependDefer(self._report_delete, 'test_rest_report1') resp = request( '/plugins/gingerbase/debugreports/test_rest_report1' ) debugreport = json.loads(resp.read()) self.assertEquals('test_rest_report1', debugreport['name']) self.assertEquals(200, resp.status) resp = request( '/plugins/gingerbase/debugreports/test_rest_report1/content' ) self.assertEquals(200, resp.status) resp = request( '/plugins/gingerbase/debugreports/test_rest_report1' ) debugre = json.loads(resp.read()) resp = request('/' + debugre['uri']) self.assertEquals(200, resp.status)
def test_vm_migrate_fails_different_remote_arch(self, mock_get_remote_conn): class MockRemoteConnObj(object): def getType(self): return 'QEMU' def getInfo(self): return ['another_arch', 'QEMU'] def close(self): pass mock_get_remote_conn.return_value = MockRemoteConnObj() with RollbackContext() as rollback: self.create_vm_test() rollback.prependDefer(rollback_wrapper, self.inst.vm_delete, 'test_vm_migrate') self.assertRaises( OperationFailed, self.inst.vm_migrate, 'test_vm_migrate', KIMCHI_LIVE_MIGRATION_TEST, )
def test_vm_storage_provisioning(self): inst = model.Model(objstore_loc=self.tmp_store) with RollbackContext() as rollback: params = { 'name': 'test', 'disks': [{ 'size': 1 }], 'cdrom': UBUNTU_ISO } inst.templates_create(params) rollback.prependDefer(inst.template_delete, 'test') params = { 'name': 'test-vm-1', 'template': '/plugins/kimchi/templates/test' } task = inst.vms_create(params) inst.task_wait(task['id']) rollback.prependDefer(inst.vm_delete, 'test-vm-1') vm_info = inst.vm_lookup(params['name']) disk_path = '%s/%s-0.img' % ( inst.storagepool_lookup('default')['path'], vm_info['uuid']) self.assertTrue(os.access(disk_path, os.F_OK)) self.assertFalse(os.access(disk_path, os.F_OK))
def test_deep_scan(self): inst = model.Model(None, objstore_loc=self.tmp_store) with RollbackContext() as rollback: deep_path = os.path.join(TMP_DIR, 'deep-scan') subdir_path = os.path.join(deep_path, 'isos') if not os.path.exists(subdir_path): os.makedirs(subdir_path) ubuntu_iso = os.path.join(deep_path, 'ubuntu12.04.iso') sles_iso = os.path.join(subdir_path, 'sles10.iso') iso_gen.construct_fake_iso(ubuntu_iso, True, '12.04', 'ubuntu') iso_gen.construct_fake_iso(sles_iso, True, '10', 'sles') args = { 'name': 'kimchi-scanning-pool', 'path': deep_path, 'type': 'kimchi-iso' } inst.storagepools_create(args) rollback.prependDefer(shutil.rmtree, deep_path) rollback.prependDefer(shutil.rmtree, args['path']) rollback.prependDefer(inst.storagepool_deactivate, args['name']) time.sleep(1) volumes = inst.storagevolumes_get_list(args['name']) self.assertEquals(len(volumes), 2)
def _configure_interface(cb, params): """ method to configure and persist network device. Rollback is performed if it fails to persist. :param interface: network device id :return: None """ osa_portno = params.get('osa_portno') interface = params.get('interface') cb('') # reset messages try: with RollbackContext() as rollback: if not _is_interface_online(interface): configured_port = _bring_online(interface, osa_portno) rollback.prependDefer(_bring_offline, interface) _create_ifcfg_file(interface) _persist_interface(interface, configured_port) rollback.commitAll() if osa_portno and osa_portno != configured_port: cb( 'Successfully configured network device "%s" on OSA port 0 ' 'since port "%s" was not available.' % (interface, osa_portno), True) else: cb('Successfully configured network device %s' % interface, True) except Exception as e: cb(e.message, False)
def test_create_user(self): users_model = UsersModel() user_model = UserModel() user = '******' passwd = 'fakepass' group = 'unit_test_fake_group' profile = 'unit_test_fake_profile' common_users = users_model.get_list() params = {'name': user, 'password': passwd, 'group': group, 'profile': profile} with RollbackContext() as rollback: users_model.create(params) rollback.prependDefer(user_model.delete, user) new_users = users_model.get_list() self.assertEqual(len(new_users), len(common_users) + 1) enc_passwd = spwd.getspnam(user)[1] invalid_passwd = [None, "NP", "!", "!!", "", "LK", "*"] self.assertNotIn(enc_passwd, invalid_passwd) self.assertEqual(crypt.crypt(passwd, enc_passwd), enc_passwd)
def has_mem_hotplug_support(conn): ''' A memory device can be hot-plugged or hot-unplugged since libvirt version 1.2.14. ''' # Libvirt < 1.2.14 does not support memory devices, so firstly, check # its version, then try to attach a device. These steps avoid errors # with Libvirt 'test' driver for KVM version = 1000000 * 1 + 1000 * 2 + 14 if libvirt.getVersion() < version: return False with RollbackContext() as rollback: FeatureTests.disable_libvirt_error_logging() rollback.prependDefer(FeatureTests.enable_libvirt_error_logging) conn_type = conn.getType().lower() domain_type = 'test' if conn_type == 'test' else 'kvm' arch = 'i686' if conn_type == 'test' else platform.machine() arch = 'ppc64' if arch == 'ppc64le' else arch dom = conn.defineXML(MAXMEM_VM_XML % { 'name': FEATURETEST_VM_NAME, 'domain': domain_type, 'arch': arch }) rollback.prependDefer(dom.undefine) try: dom.attachDeviceFlags(DEV_MEM_XML, libvirt.VIR_DOMAIN_MEM_CONFIG) return True except libvirt.libvirtError: return False
def test_set_plugin_state(self, mock_update_cherrypy, mock_config_file): mock_update_cherrypy.return_value = True with RollbackContext() as rollback: config_file_name = self._create_fake_config_file() rollback.prependDefer(os.remove, config_file_name) mock_config_file.return_value = config_file_name set_plugin_state('pluginA', False) with open(config_file_name, 'r') as f: updated_conf = f.read() self.assertEqual( updated_conf, self._get_config_file_template(enable=False) ) set_plugin_state('pluginA', True) with open(config_file_name, 'r') as f: updated_conf = f.read() self.assertEqual( updated_conf, self._get_config_file_template(enable=True) )
def test_vm_livemigrate_persistent(self): inst = model.Model(libvirt_uri='qemu:///system', objstore_loc=self.tmp_store) with RollbackContext() as rollback: self.create_vm_test() rollback.prependDefer(utils.rollback_wrapper, self.inst.vm_delete, u'test_vm_migrate') # removing cdrom because it is not shared storage and will make # the migration fail dev_list = self.inst.vmstorages_get_list('test_vm_migrate') self.inst.vmstorage_delete('test_vm_migrate', dev_list[0]) try: self.inst.vm_start('test_vm_migrate') except Exception, e: self.fail('Failed to start the vm, reason: %s' % e.message) try: task = inst.vm_migrate('test_vm_migrate', KIMCHI_LIVE_MIGRATION_TEST) inst.task_wait(task['id']) self.assertIn('test_vm_migrate', self.get_remote_vm_list()) remote_conn = self.get_remote_conn() rollback.prependDefer(remote_conn.close) remote_vm = remote_conn.lookupByName('test_vm_migrate') self.assertTrue(remote_vm.isPersistent()) remote_vm.destroy() remote_vm.undefine() except Exception, e: self.fail('Migration test failed: %s' % e.message)
def test_use_test_host(self): inst = model.Model('test:///default', objstore_loc=self.tmp_store) with RollbackContext() as rollback: params = { 'name': 'test', 'disks': [], 'cdrom': UBUNTU_ISO, 'storagepool': '/plugins/kimchi/storagepools/default-pool', 'domain': 'test', 'arch': 'i686' } inst.templates_create(params) rollback.prependDefer(inst.template_delete, 'test') params = {'name': 'kimchi-vm', 'template': '/plugins/kimchi/templates/test'} task = inst.vms_create(params) inst.task_wait(task['id']) rollback.prependDefer(inst.vm_delete, 'kimchi-vm') vms = inst.vms_get_list() self.assertTrue('kimchi-vm' in vms)
def test_vm_coldmigrate(self): with RollbackContext() as rollback: self.create_vm_test() rollback.prependDefer(rollback_wrapper, self.inst.vm_delete, u'test_vm_migrate') # removing cdrom because it is not shared storage and will make # the migration fail dev_list = self.inst.vmstorages_get_list('test_vm_migrate') self.inst.vmstorage_delete('test_vm_migrate', dev_list[0]) try: task = self.inst.vm_migrate('test_vm_migrate', KIMCHI_LIVE_MIGRATION_TEST) self.inst.task_wait(task['id']) self.assertIn('test_vm_migrate', self.get_remote_vm_list()) remote_conn = self.get_remote_conn() rollback.prependDefer(remote_conn.close) remote_vm = remote_conn.lookupByName('test_vm_migrate') self.assertTrue(remote_vm.isPersistent()) state = remote_vm.info()[0] self.assertEqual(state, libvirt.VIR_DOMAIN_SHUTOFF) remote_vm.undefine() except Exception, e: self.fail('Migration test failed: %s' % e.message)
def probe_user(cls): with cls.lock: if cls.user: return cls.user arch = 'ppc64' if platform.machine( ) == 'ppc64le' else platform.machine() xml = cls.SIMPLE_VM_XML % {'name': KVMUSERTEST_VM_NAME, 'arch': arch} with RollbackContext() as rollback: with cls.lock: conn = libvirt.open(None) rollback.prependDefer(conn.close) f = libvirt.VIR_DOMAIN_START_AUTODESTROY dom = conn.createXML(xml, flags=f) rollback.prependDefer(dom.destroy) filename = get_libvirt_path( ) + '/qemu/%s.pid' % KVMUSERTEST_VM_NAME with open(filename) as f: pidStr = f.read() p = psutil.Process(int(pidStr)) # bug fix #357 # in psutil 2.0 and above versions, username will be a method, # not a string if callable(p.username): cls.user = p.username() else: cls.user = p.username return cls.user
def test_empty_repo_file(self): with RollbackContext() as rollback: repos = get_yum_repositories() tmp_file_name = _create_empty_repo_file() rollback.prependDefer(os.remove, tmp_file_name) repos_after = get_yum_repositories() self.assertEqual(len(repos_after), len(repos))
def prepare(self, conn): mnt_point = tempfile.mkdtemp(dir='/tmp') export_path = "%s:%s" % (self.poolArgs['source']['host'], self.poolArgs['source']['path']) mount_cmd = [ "mount", "-o", 'soft,timeo=100,retrans=3,retry=0', export_path, mnt_point ] umount_cmd = ["umount", "-f", export_path] mounted = False # Due to an NFS bug (See Red Hat BZ 1023059), NFSv4 exports may take # 10-15 seconds to mount the first time. cmd_timeout = 15 with RollbackContext() as rollback: rollback.prependDefer(os.rmdir, mnt_point) try: run_command(mount_cmd, cmd_timeout) rollback.prependDefer(run_command, umount_cmd, cmd_timeout) except TimeoutExpired: raise InvalidParameter("KCHPOOL0012E", {'path': export_path}) with open("/proc/mounts", "rb") as f: rawMounts = f.read() output_items = ['dev_path', 'mnt_point', 'type'] mounts = parse_cmd_output(rawMounts, output_items) for item in mounts: if 'dev_path' in item and item['dev_path'] == export_path: mounted = True if not mounted: raise InvalidParameter("KCHPOOL0013E", {'path': export_path})
def test_vm_memory_hotplug(self): config.set("authentication", "method", "pam") inst = model.Model(None, objstore_loc=self.tmp_store) orig_params = {'name': 'test', 'memory': 1024, 'cdrom': UBUNTU_ISO} inst.templates_create(orig_params) with RollbackContext() as rollback: params = {'name': 'kimchi-vm1', 'template': '/plugins/kimchi/templates/test'} task1 = inst.vms_create(params) inst.task_wait(task1['id']) rollback.prependDefer(utils.rollback_wrapper, inst.vm_delete, 'kimchi-vm1') # Start vm inst.vm_start('kimchi-vm1') rollback.prependDefer(utils.rollback_wrapper, inst.vm_poweroff, 'kimchi-vm1') # Hotplug memory, only available in Libvirt >= 1.2.14 params = {'memory': 2048} if inst.capabilities_lookup()['mem_hotplug_support']: inst.vm_update('kimchi-vm1', params) rollback.prependDefer(utils.rollback_wrapper, inst.vm_delete, 'kimchi-vm1') self.assertEquals(params['memory'], inst.vm_lookup('kimchi-vm1')['memory']) else: self.assertRaises(InvalidOperation, inst.vm_update, 'kimchi-vm1', params)
def test_get_networks(self): networks = json.loads(self.request('/plugins/kimchi/networks').read()) self.assertIn('default', [net['name'] for net in networks]) with RollbackContext() as rollback: # Now add a couple of Networks to the mock model for i in xrange(5): name = 'network-%i' % i req = json.dumps({ 'name': name, 'connection': 'nat', 'subnet': '127.0.10%i.0/24' % i }) resp = self.request('/plugins/kimchi/networks', req, 'POST') rollback.prependDefer(model.network_delete, name) self.assertEquals(201, resp.status) network = json.loads(resp.read()) self.assertEquals([], network["vms"]) nets = json.loads(self.request('/plugins/kimchi/networks').read()) self.assertEquals(len(networks) + 5, len(nets)) network = json.loads( self.request('/plugins/kimchi/networks/network-1').read()) keys = [ u'name', u'connection', u'interfaces', u'subnet', u'dhcp', u'vms', u'in_use', u'autostart', u'state', u'persistent' ] self.assertEquals(sorted(keys), sorted(network.keys()))
def test_vm_graphics(self): inst = model.Model(objstore_loc=self.tmp_store) params = {'name': 'test', 'disks': [], 'cdrom': UBUNTU_ISO} inst.templates_create(params) with RollbackContext() as rollback: params = {'name': 'kimchi-vnc', 'template': '/plugins/kimchi/templates/test'} task1 = inst.vms_create(params) inst.task_wait(task1['id']) rollback.prependDefer(inst.vm_delete, 'kimchi-vnc') info = inst.vm_lookup('kimchi-vnc') self.assertEquals('vnc', info['graphics']['type']) self.assertEquals('127.0.0.1', info['graphics']['listen']) graphics = {'type': 'spice', 'listen': '127.0.0.1'} params = {'name': 'kimchi-spice', 'template': '/plugins/kimchi/templates/test', 'graphics': graphics} task2 = inst.vms_create(params) inst.task_wait(task2['id']) rollback.prependDefer(inst.vm_delete, 'kimchi-spice') info = inst.vm_lookup('kimchi-spice') self.assertEquals('spice', info['graphics']['type']) self.assertEquals('127.0.0.1', info['graphics']['listen']) inst.template_delete('test')
def test_mount_existing_fs_fails(self): fs = filesystem.FileSystemsModel() fsd = filesystem.FileSystemModel() create_file(self) fstype = 'local' blkdev = '/testfile' mntpt = '/test' persistent = False with RollbackContext() as rollback: fs.create({ 'type': fstype, 'blk_dev': blkdev, 'mount_point': mntpt, 'persistent': persistent }) rollback.prependDefer(fsd.delete, mntpt) with self.assertRaises(InvalidParameter): fs.create({ 'type': fstype, 'blk_dev': blkdev, 'mount_point': mntpt, 'persistent': persistent }) delete_file(self)
def create(self, vmid, params): dev_name = params['name'] dev_info = self.dev_model.lookup(dev_name) if dev_info['device_type'] == 'pci': taskid = AsyncTask( u'/plugins/kimchi/vms/%s/hostdevs/' % VMModel.get_vm(vmid, self.conn).name(), self._attach_pci_device, {'vmid': vmid, 'dev_info': dev_info, 'lock': threading.RLock()}, ).id return self.task.lookup(taskid) with RollbackContext() as rollback: try: dev = self.conn.get().nodeDeviceLookupByName(dev_name) dev.dettach() except Exception: raise OperationFailed('KCHVMHDEV0005E', {'name': dev_name}) else: rollback.prependDefer(dev.reAttach) rollback.commitAll() taskid = AsyncTask( u'/plugins/kimchi/vms/%s/hostdevs/' % VMModel.get_vm(vmid, self.conn).name(), '_attach_%s_device' % dev_info['device_type'], {'vmid': vmid, 'dev_info': dev_info, 'lock': threading.RLock()}, ).id return self.task.lookup(taskid)
def test_mount_local_fs(self): fs = filesystem.FileSystemsModel() fsd = filesystem.FileSystemModel() create_file(self) fstype = 'local' blkdev = '/testfile' mntpt = '/test' persistent = False fs_list = fs.get_list() with RollbackContext() as rollback: fs.create({ 'type': fstype, 'blk_dev': blkdev, 'mount_point': mntpt, 'persistent': persistent }) rollback.prependDefer(fsd.delete, mntpt) new_fs_list = fs.get_list() self.assertEqual(len(new_fs_list), len(fs_list) + 1) delete_file(self)
def test_vm_livemigrate_persistent_API(self): patch_auth() inst = model.Model(libvirt_uri='qemu:///system', objstore_loc=self.tmp_store) host = '127.0.0.1' port = get_free_port('http') ssl_port = get_free_port('https') cherrypy_port = get_free_port('cherrypy_port') with RollbackContext() as rollback: test_server = run_server(host, port, ssl_port, test_mode=True, cherrypy_port=cherrypy_port, model=inst) rollback.prependDefer(test_server.stop) self.request = partial(request, host, ssl_port) self.create_vm_test() rollback.prependDefer(rollback_wrapper, self.inst.vm_delete, u'test_vm_migrate') # removing cdrom because it is not shared storage and will make # the migration fail dev_list = self.inst.vmstorages_get_list('test_vm_migrate') self.inst.vmstorage_delete('test_vm_migrate', dev_list[0]) try: self.inst.vm_start('test_vm_migrate') except Exception, e: self.fail('Failed to start the vm, reason: %s' % e.message) migrate_url = "/plugins/kimchi/vms/%s/migrate" % 'test_vm_migrate' req = json.dumps({ 'remote_host': KIMCHI_LIVE_MIGRATION_TEST, 'user': '******' }) resp = self.request(migrate_url, req, 'POST') self.assertEquals(202, resp.status) task = json.loads(resp.read()) wait_task(self._task_lookup, task['id']) task = json.loads( self.request('/plugins/kimchi/tasks/%s' % task['id'], '{}').read()) self.assertEquals('finished', task['status']) try: remote_conn = self.get_remote_conn() rollback.prependDefer(remote_conn.close) remote_vm = remote_conn.lookupByName('test_vm_migrate') self.assertTrue(remote_vm.isPersistent()) remote_vm.destroy() remote_vm.undefine() except Exception, e: self.fail('Migration test failed: %s' % e.message)
def test_delete_running_vm(self): inst = model.Model(objstore_loc=self.tmp_store) with RollbackContext() as rollback: params = {'name': u'test', 'disks': [], 'cdrom': UBUNTU_ISO} inst.templates_create(params) rollback.prependDefer(inst.template_delete, 'test') params = { 'name': u'kīмсhī-∨м', 'template': u'/plugins/kimchi/templates/test' } task = inst.vms_create(params) inst.task_wait(task['id']) rollback.prependDefer(utils.rollback_wrapper, inst.vm_delete, u'kīмсhī-∨м') inst.vm_start(u'kīмсhī-∨м') self.assertEquals(inst.vm_lookup(u'kīмсhī-∨м')['state'], 'running') rollback.prependDefer(utils.rollback_wrapper, inst.vm_poweroff, u'kīмсhī-∨м') inst.vm_delete(u'kīмсhī-∨м') vms = inst.vms_get_list() self.assertFalse(u'kīмсhī-∨м' in vms)
def create(self, vmid, params): dev_name = params['name'] self._passthrough_device_validate(dev_name) dev_info = DeviceModel(conn=self.conn).lookup(dev_name) if dev_info['device_type'] == 'pci': taskid = add_task( u'/plugins/kimchi/vms/%s/hostdevs/' % VMModel.get_vm(vmid, self.conn).name(), self._attach_pci_device, self.objstore, { 'vmid': vmid, 'dev_info': dev_info }) return self.task.lookup(taskid) with RollbackContext() as rollback: try: dev = self.conn.get().nodeDeviceLookupByName(dev_name) dev.dettach() except Exception: raise OperationFailed('KCHVMHDEV0005E', {'name': dev_name}) else: rollback.prependDefer(dev.reAttach) rollback.commitAll() taskid = add_task( u'/plugins/kimchi/vms/%s/hostdevs/' % VMModel.get_vm(vmid, self.conn).name(), '_attach_%s_device' % dev_info['device_type'], self.objstore, { 'vmid': vmid, 'dev_info': dev_info }) return self.task.lookup(taskid)
def test_template_creates_user_defined_vol_format_instead_default(self): inst = model.Model(objstore_loc=self.tmp_store) default_vol = 'vmdk' user_vol = 'raw' with RollbackContext() as rollback: self._create_template_conf_with_disk_format(default_vol) rollback.prependDefer(self._restore_template_conf_file) params = {'name': 'test', 'disks': [{'size': 1, 'format': user_vol}], 'cdrom': UBUNTU_ISO} inst.templates_create(params) rollback.prependDefer(inst.template_delete, 'test') params = {'name': 'test-vm-1', 'template': '/plugins/kimchi/templates/test'} task = inst.vms_create(params) inst.task_wait(task['id']) rollback.prependDefer(inst.vm_delete, 'test-vm-1') created_disk_format = self._get_disk_format_from_vm( 'test-vm-1', inst.conn ) self.assertEqual(created_disk_format, user_vol)
def test_vm_migrate_fails_if_not_passwordless_login(self): with RollbackContext() as rollback: self.create_vm_test() rollback.prependDefer(rollback_wrapper, self.inst.vm_delete, u'test_vm_migrate') self.assertRaises(OperationFailed, self.inst.vm_migrate, 'test_vm_migrate', 'this_is_a_fake_remote_host')
def test_vm_migrate_fails_if_remotehost_unreachable(self): with RollbackContext() as rollback: self.create_vm_test() rollback.prependDefer(rollback_wrapper, self.inst.vm_delete, u'test_vm_migrate') self.assertRaises(OperationFailed, self.inst.vm_migrate, 'test_vm_migrate', 'test.vm.migrate.host.unreachable')
def test_create_existing_user_fails(self): user = '******' passwd = 'fakepass' with RollbackContext() as rollback: users.create_user(user, passwd) rollback.prependDefer(users.delete_user, user) with self.assertRaises(OperationFailed): users.create_user(user, passwd)
def test_create_group(self): groupname = 'unit_test_fake_group' groups = users.get_groups() with RollbackContext() as rollback: users.create_group(groupname, 9999) rollback.prependDefer(users.delete_group, groupname) new_groups = users.get_groups() self.assertEqual(len(new_groups), len(groups) + 1)