Qubes/core-admin
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge branch 'tests20201030'

Browse Source 
* tests20201030:
  tests: fix test_550_ipv6_spoof_ip
  tests: wait for full VM startup before testing network and few other
  tests: fix logging network info on failed test
  tests: use dup-ed stdin in wait_on_fail
  tests: add PVH grub2 tests
  tests: adjust for applications list stored in features dict
  tests: remove test_030_clone
  tests: make sure dnsmasq is stopped before starting it again
  tests: fail the test early if VM fails to start
This commit is contained in:
Marek Marczykowski-Górecki 2020-11-26 22:44:39 +01:00
commit b3bb65d3b0
No known key found for this signature in database
GPG Key ID: 063938BA42CFA724
9 changed files with 114 additions and 195 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
qubes/tests/__init__.py
View File

@ -249,7 +249,7 @@ def wait_on_fail(func):
transport, protocol = self.loop.run_until_complete(
self.loop.connect_read_pipe(
lambda: asyncio.StreamReaderProtocol(reader),
sys.stdin))
os.fdopen(os.dup(sys.stdin.fileno()))))
self.loop.run_until_complete(reader.readline())
transport.close()
raise
@ -1277,7 +1277,7 @@ class SystemTestCase(QubesTestCase):
@asyncio.coroutine
def wait_for_session(self, vm):
timeout = 30
timeout = vm.qrexec_timeout
if getattr(vm, 'template', None) and 'whonix-ws' in vm.template.name:
# first boot of whonix-ws takes more time because of /home
# initialization, including Tor Browser copying
@ -1287,6 +1287,12 @@ class SystemTestCase(QubesTestCase):
'qubes.WaitForSession', input=vm.default_user.encode()),
timeout=timeout)
@asyncio.coroutine
def start_vm(self, vm):
"""Start a VM and wait for it to be fully up"""
yield from vm.start()
yield from self.wait_for_session(vm)
_templates = None

14
qubes/tests/integ/backupcompatibility.py
View File

@ -426,12 +426,17 @@ class TC_00_BackupCompatibility(
'debug': False,
'maxmem': min(int(self.app.host.memory_total / 1024 / 2), 4000),
'memory': 400,
'features': {},
'features': {
'menu-items': 'gnome-terminal.desktop nautilus.desktop '
'firefox.desktop mozilla-thunderbird.desktop '
'libreoffice-startcenter.desktop',
},
}
template_standalone_props = common_props.copy()
template_standalone_props['features'] = {
'qrexec': '1',
'gui': '1',
'menu-items': common_props['features']['menu-items'],
}
self.assertRestored("test-template-clone",
klass=qubes.vm.templatevm.TemplateVM,
@ -481,12 +486,17 @@ class TC_00_BackupCompatibility(
'debug': False,
'maxmem': min(int(self.app.host.memory_total / 1024 / 2), 4000),
'memory': 400,
'features': {},
'features': {
'menu-items': 'gnome-terminal.desktop nautilus.desktop '
'firefox.desktop mozilla-thunderbird.desktop '
'libreoffice-startcenter.desktop',
},
}
template_standalone_props = common_props.copy()
template_standalone_props['features'] = {
'qrexec': '1',
'gui': '1',
'menu-items': common_props['features']['menu-items'],
}
self.assertRestored("test-template-clone",
klass=qubes.vm.templatevm.TemplateVM,

114
qubes/tests/integ/basic.py
View File

@ -370,112 +370,6 @@ class TC_01_Properties(qubes.tests.SystemTestCase):
def cleanup_props(self):
del self.vm
def test_030_clone(self):
try:
testvm1 = self.app.add_new_vm(
qubes.vm.appvm.AppVM,
name=self.make_vm_name("vm"),
template=self.app.default_template,
label='red')
self.loop.run_until_complete(testvm1.create_on_disk())
testvm2 = self.app.add_new_vm(testvm1.__class__,
name=self.make_vm_name("clone"),
template=testvm1.template,
label='red')
testvm2.clone_properties(testvm1)
testvm2.firewall.clone(testvm1.firewall)
self.loop.run_until_complete(testvm2.clone_disk_files(testvm1))
self.assertTrue(self.loop.run_until_complete(testvm1.storage.verify()))
self.assertIn('source', testvm1.volumes['root'].config)
self.assertNotEquals(testvm2, None)
self.assertNotEquals(testvm2.volumes, {})
self.assertIn('source', testvm2.volumes['root'].config)
# qubes.xml reload
self.app.save()
testvm1 = self.app.domains[testvm1.qid]
testvm2 = self.app.domains[testvm2.qid]
self.assertEqual(testvm1.label, testvm2.label)
self.assertEqual(testvm1.netvm, testvm2.netvm)
self.assertEqual(testvm1.property_is_default('netvm'),
testvm2.property_is_default('netvm'))
self.assertEqual(testvm1.kernel, testvm2.kernel)
self.assertEqual(testvm1.kernelopts, testvm2.kernelopts)
self.assertEqual(testvm1.property_is_default('kernel'),
testvm2.property_is_default('kernel'))
self.assertEqual(testvm1.property_is_default('kernelopts'),
testvm2.property_is_default('kernelopts'))
self.assertEqual(testvm1.memory, testvm2.memory)
self.assertEqual(testvm1.maxmem, testvm2.maxmem)
self.assertEqual(testvm1.devices, testvm2.devices)
self.assertEqual(testvm1.include_in_backups,
testvm2.include_in_backups)
self.assertEqual(testvm1.default_user, testvm2.default_user)
self.assertEqual(testvm1.features, testvm2.features)
self.assertEqual(testvm1.firewall.rules,
testvm2.firewall.rules)
# now some non-default values
testvm1.netvm = None
testvm1.label = 'orange'
testvm1.memory = 512
firewall = testvm1.firewall
firewall.rules = [
qubes.firewall.Rule(None, action='accept', dsthost='1.2.3.0/24',
proto='tcp', dstports=22)]
firewall.save()
testvm3 = self.app.add_new_vm(testvm1.__class__,
name=self.make_vm_name("clone2"),
template=testvm1.template,
label='red',)
testvm3.clone_properties(testvm1)
testvm3.firewall.clone(testvm1.firewall)
self.loop.run_until_complete(testvm3.clone_disk_files(testvm1))
# qubes.xml reload
self.app.save()
testvm1 = self.app.domains[testvm1.qid]
testvm3 = self.app.domains[testvm3.qid]
self.assertEqual(testvm1.label, testvm3.label)
self.assertEqual(testvm1.netvm, testvm3.netvm)
self.assertEqual(testvm1.property_is_default('netvm'),
testvm3.property_is_default('netvm'))
self.assertEqual(testvm1.kernel, testvm3.kernel)
self.assertEqual(testvm1.kernelopts, testvm3.kernelopts)
self.assertEqual(testvm1.property_is_default('kernel'),
testvm3.property_is_default('kernel'))
self.assertEqual(testvm1.property_is_default('kernelopts'),
testvm3.property_is_default('kernelopts'))
self.assertEqual(testvm1.memory, testvm3.memory)
self.assertEqual(testvm1.maxmem, testvm3.maxmem)
self.assertEqual(testvm1.devices, testvm3.devices)
self.assertEqual(testvm1.include_in_backups,
testvm3.include_in_backups)
self.assertEqual(testvm1.default_user, testvm3.default_user)
self.assertEqual(testvm1.features, testvm3.features)
self.assertEqual(testvm1.firewall.rules,
testvm3.firewall.rules)
finally:
try:
del firewall
except NameError:
pass
try:
del testvm1
except NameError:
pass
try:
del testvm2
except NameError:
pass
try:
del testvm3
except NameError:
pass
def test_020_name_conflict_app(self):
# TODO decide what exception should be here
with self.assertRaises((qubes.exc.QubesException, ValueError)):
@ -580,12 +474,12 @@ class TC_30_Gui_daemon(qubes.tests.SystemTestCase):
self.loop.run_until_complete(testvm2.create_on_disk())
self.app.save()
self.loop.run_until_complete(asyncio.wait([
self.loop.run_until_complete(asyncio.gather(
testvm1.start(),
testvm2.start()]))
self.loop.run_until_complete(asyncio.wait([
testvm2.start()))
self.loop.run_until_complete(asyncio.gather(
self.wait_for_session(testvm1),
self.wait_for_session(testvm2)]))
self.wait_for_session(testvm2)))
window_title = 'user@{}'.format(testvm1.name)
self.loop.run_until_complete(testvm1.run(
'zenity --text-info --editable --title={}'.format(window_title)))

12
qubes/tests/integ/grub.py
View File

@ -57,6 +57,9 @@ class GrubBase(object):
else:
assert False, "Unsupported template?!"
# wait for full VM startup first, to have functional network
self.loop.run_until_complete(self.wait_for_session(vm))
for cmd in [cmd_install1, cmd_install2, cmd_update_grub]:
try:
self.loop.run_until_complete(vm.run_for_stdio(
@ -158,6 +161,12 @@ class TC_41_HVMGrub(GrubBase):
virt_mode = 'hvm'
kernel = None
@unittest.skipUnless(os.path.exists('/var/lib/qubes/vm-kernels/pvgrub2-pvh'),
'grub2-xen-pvh package not installed')
class TC_42_PVHGrub(GrubBase):
virt_mode = 'pvh'
kernel = 'pvgrub2-pvh'
def create_testcases_for_templates():
yield from qubes.tests.create_testcases_for_templates('TC_40_PVGrub',
TC_40_PVGrub, qubes.tests.SystemTestCase,
@ -165,6 +174,9 @@ def create_testcases_for_templates():
yield from qubes.tests.create_testcases_for_templates('TC_41_HVMGrub',
TC_41_HVMGrub, qubes.tests.SystemTestCase,
module=sys.modules[__name__])
yield from qubes.tests.create_testcases_for_templates('TC_42_PVHGrub',
TC_42_PVHGrub, qubes.tests.SystemTestCase,
module=sys.modules[__name__])
def load_tests(loader, tests, pattern):
tests.addTests(loader.loadTestsFromNames(

4
qubes/tests/integ/mime.py
View File

@ -65,9 +65,9 @@ class TC_50_MimeHandlers:
self.target_vm.template_for_dispvms = True
self.source_vm.default_dispvm = self.target_vm
done, not_done = self.loop.run_until_complete(asyncio.wait([
done, not_done = self.loop.run_until_complete(asyncio.gather(
self.source_vm.start(),
self.target_vm.start()]))
self.target_vm.start()))
for result in itertools.chain(done, not_done):
# catch any exceptions
result.result()

65
qubes/tests/integ/network.py
View File

@ -92,9 +92,9 @@ class VmNetworkingMixin(object):
if not vm.is_running():
return
with contextlib.suppress(subprocess.CalledProcessError):
output = self.loop.run_until_complete(
self.testnetvm.run_for_stdio(cmd, user='root'))
self.log.error('{}: {}: {}'.format(vm.name, cmd, output))
output, _ = self.loop.run_until_complete(
vm.run_for_stdio(cmd, user='root', stderr=subprocess.STDOUT))
self.log.critical('{}: {}: {}'.format(vm.name, cmd, output))
def tearDown(self):
# collect more info on failure
@ -110,6 +110,7 @@ class VmNetworkingMixin(object):
self._run_cmd_and_log_output(vm, 'systemctl --no-pager status qubes-firewall')
self._run_cmd_and_log_output(vm, 'systemctl --no-pager status qubes-iptables')
self._run_cmd_and_log_output(vm, 'systemctl --no-pager status xendriverdomain')
self._run_cmd_and_log_output(vm, 'cat /var/log/xen/xen-hotplug.log')
super(VmNetworkingMixin, self).tearDown()
@ -141,7 +142,7 @@ class VmNetworkingMixin(object):
run_netvm_cmd("iptables -I INPUT -d {} -j ACCEPT --wait".format(
self.test_ip))
# ignore failure
self.run_cmd(self.testnetvm, "pkill dnsmasq")
self.run_cmd(self.testnetvm, "while pkill dnsmasq; do sleep 1; done")
run_netvm_cmd("dnsmasq -a {ip} -A /{name}/{ip} -i test0 -z".format(
ip=self.test_ip, name=self.test_name))
run_netvm_cmd("echo nameserver {} > /etc/resolv.conf".format(
@ -153,7 +154,7 @@ class VmNetworkingMixin(object):
'''
:type self: qubes.tests.SystemTestCase | VMNetworkingMixin
'''
self.loop.run_until_complete(self.testvm1.start())
self.loop.run_until_complete(self.start_vm(self.testvm1))
self.assertEqual(self.run_cmd(self.testvm1, self.ping_ip), 0)
self.assertEqual(self.run_cmd(self.testvm1, self.ping_name), 0)
@ -171,7 +172,7 @@ class VmNetworkingMixin(object):
self.testvm1.netvm = self.proxy
self.app.save()
self.loop.run_until_complete(self.testvm1.start())
self.loop.run_until_complete(self.start_vm(self.testvm1))
self.assertTrue(self.proxy.is_running())
self.assertEqual(self.run_cmd(self.proxy, self.ping_ip), 0,
"Ping by IP from ProxyVM failed")
@ -200,7 +201,7 @@ class VmNetworkingMixin(object):
self.testvm1.netvm = self.proxy
self.app.save()
self.loop.run_until_complete(self.testvm1.start())
self.loop.run_until_complete(self.start_vm(self.testvm1))
self.assertTrue(self.proxy.is_running())
self.assertEqual(self.run_cmd(self.testvm1, self.ping_ip), 0,
"Ping by IP failed")
@ -251,7 +252,7 @@ class VmNetworkingMixin(object):
self.testvm1.firewall.rules = [qubes.firewall.Rule(action='drop')]
self.testvm1.firewall.save()
self.loop.run_until_complete(self.testvm1.start())
self.loop.run_until_complete(self.start_vm(self.testvm1))
self.assertTrue(self.proxy.is_running())
server = self.loop.run_until_complete(self.testnetvm.run(
@ -350,9 +351,9 @@ class VmNetworkingMixin(object):
self.testvm2.netvm = self.proxy
self.app.save()
self.loop.run_until_complete(asyncio.wait([
self.testvm1.start(),
self.testvm2.start()]))
self.loop.run_until_complete(asyncio.gather(
self.start_vm(self.testvm1),
self.start_vm(self.testvm2)))
self.assertNotEqual(self.run_cmd(self.testvm1,
self.ping_cmd.format(target=self.testvm2.ip)), 0)
@ -376,7 +377,7 @@ class VmNetworkingMixin(object):
:type self: qubes.tests.SystemTestCase | VMNetworkingMixin
'''
self.loop.run_until_complete(self.testvm1.start())
self.loop.run_until_complete(self.start_vm(self.testvm1))
self.assertEqual(self.run_cmd(self.testvm1, self.ping_ip), 0)
self.assertEqual(self.run_cmd(self.testnetvm,
@ -409,7 +410,7 @@ class VmNetworkingMixin(object):
cmd = "systemctl stop xendriverdomain"
if self.run_cmd(self.testnetvm, cmd) != 0:
self.fail("Command '%s' failed" % cmd)
self.loop.run_until_complete(self.testvm1.start())
self.loop.run_until_complete(self.start_vm(self.testvm1))
cmd = "systemctl start xendriverdomain"
if self.run_cmd(self.testnetvm, cmd) != 0:
@ -422,7 +423,7 @@ class VmNetworkingMixin(object):
def test_110_dynamic_attach(self):
self.testvm1.netvm = None
self.loop.run_until_complete(self.testvm1.start())
self.loop.run_until_complete(self.start_vm(self.testvm1))
self.testvm1.netvm = self.testnetvm
# wait for it to settle down
self.loop.run_until_complete(self.testvm1.run_for_stdio(
@ -430,7 +431,7 @@ class VmNetworkingMixin(object):
self.assertEqual(self.run_cmd(self.testvm1, self.ping_ip), 0)
def test_111_dynamic_detach_attach(self):
self.loop.run_until_complete(self.testvm1.start())
self.loop.run_until_complete(self.start_vm(self.testvm1))
self.testvm1.netvm = None
# wait for it to settle down
self.loop.run_until_complete(self.testvm1.run_for_stdio(
@ -450,9 +451,9 @@ class VmNetworkingMixin(object):
self.loop.run_until_complete(self.proxy.create_on_disk())
self.testvm1.netvm = self.proxy
self.loop.run_until_complete(self.testvm1.start())
self.loop.run_until_complete(self.start_vm(self.testvm1))
self.loop.run_until_complete(self.proxy.shutdown(force=True, wait=True))
self.loop.run_until_complete(self.proxy.start())
self.loop.run_until_complete(self.start_vm(self.proxy))
# wait for it to settle down
self.loop.run_until_complete(self.wait_for_session(self.proxy))
self.assertEqual(self.run_cmd(self.testvm1, self.ping_ip), 0)
@ -466,11 +467,9 @@ class VmNetworkingMixin(object):
self.loop.run_until_complete(self.proxy.create_on_disk())
self.testvm1.netvm = self.proxy
self.loop.run_until_complete(self.testvm1.start())
self.loop.run_until_complete(self.start_vm(self.testvm1))
self.loop.run_until_complete(self.proxy.kill())
self.loop.run_until_complete(self.proxy.start())
# wait for it to settle down
self.loop.run_until_complete(self.wait_for_session(self.proxy))
self.loop.run_until_complete(self.start_vm(self.proxy))
self.assertEqual(self.run_cmd(self.testvm1, self.ping_ip), 0)
def test_114_reattach_after_provider_crash(self):
@ -482,7 +481,7 @@ class VmNetworkingMixin(object):
self.loop.run_until_complete(self.proxy.create_on_disk())
self.testvm1.netvm = self.proxy
self.loop.run_until_complete(self.testvm1.start())
self.loop.run_until_complete(self.start_vm(self.testvm1))
p = self.loop.run_until_complete(self.proxy.run(
'echo c > /proc/sysrq-trigger', user='root'))
self.loop.run_until_complete(p.wait())
@ -492,9 +491,7 @@ class VmNetworkingMixin(object):
timeout -= 1
self.assertGreater(timeout, 0,
'timeout waiting for crash cleanup')
self.loop.run_until_complete(self.proxy.start())
# wait for it to settle down
self.loop.run_until_complete(self.wait_for_session(self.proxy))
self.loop.run_until_complete(self.start_vm(self.proxy))
self.assertEqual(self.run_cmd(self.testvm1, self.ping_ip), 0)
def test_200_fake_ip_simple(self):
@ -506,7 +503,7 @@ class VmNetworkingMixin(object):
self.testvm1.features['net.fake-gateway'] = '192.168.1.1'
self.testvm1.features['net.fake-netmask'] = '255.255.255.0'
self.app.save()
self.loop.run_until_complete(self.testvm1.start())
self.loop.run_until_complete(self.start_vm(self.testvm1))
self.assertEqual(self.run_cmd(self.testvm1, self.ping_ip), 0)
self.assertEqual(self.run_cmd(self.testvm1, self.ping_name), 0)
@ -538,7 +535,7 @@ class VmNetworkingMixin(object):
'''
self.testvm1.features['net.fake-ip'] = '192.168.1.128'
self.app.save()
self.loop.run_until_complete(self.testvm1.start())
self.loop.run_until_complete(self.start_vm(self.testvm1))
self.assertEqual(self.run_cmd(self.testvm1, self.ping_ip), 0)
self.assertEqual(self.run_cmd(self.testvm1, self.ping_name), 0)
@ -578,7 +575,7 @@ class VmNetworkingMixin(object):
qubes.firewall.Rule(None, action='accept', specialtarget='dns'),
]
self.testvm1.firewall.save()
self.loop.run_until_complete(self.testvm1.start())
self.loop.run_until_complete(self.start_vm(self.testvm1))
self.assertTrue(self.proxy.is_running())
server = self.loop.run_until_complete(self.testnetvm.run(
@ -623,8 +620,8 @@ class VmNetworkingMixin(object):
self.testvm2.netvm = self.proxy
self.app.save()
self.loop.run_until_complete(self.testvm1.start())
self.loop.run_until_complete(self.testvm2.start())
self.loop.run_until_complete(self.start_vm(self.testvm1))
self.loop.run_until_complete(self.start_vm(self.testvm2))
cmd = 'iptables -I FORWARD -s {} -d {} -j ACCEPT'.format(
self.testvm2.ip, self.testvm1.ip)
@ -672,7 +669,7 @@ class VmNetworkingMixin(object):
self.proxy.features['net.fake-netmask'] = '255.255.255.0'
self.testvm1.netvm = self.proxy
self.app.save()
self.loop.run_until_complete(self.testvm1.start())
self.loop.run_until_complete(self.start_vm(self.testvm1))
self.assertEqual(self.run_cmd(self.proxy, self.ping_ip), 0)
self.assertEqual(self.run_cmd(self.proxy, self.ping_name), 0)
@ -727,7 +724,7 @@ class VmNetworkingMixin(object):
'''
self.testvm1.ip = '192.168.1.1'
self.app.save()
self.loop.run_until_complete(self.testvm1.start())
self.loop.run_until_complete(self.start_vm(self.testvm1))
self.assertEqual(self.run_cmd(self.testvm1, self.ping_ip), 0)
self.assertEqual(self.run_cmd(self.testvm1, self.ping_name), 0)
@ -746,7 +743,7 @@ class VmNetworkingMixin(object):
self.testvm1.netvm = self.proxy
self.app.save()
self.loop.run_until_complete(self.testvm1.start())
self.loop.run_until_complete(self.start_vm(self.testvm1))
self.assertEqual(self.run_cmd(self.testvm1, self.ping_ip), 0)
self.assertEqual(self.run_cmd(self.testvm1, self.ping_name), 0)
@ -774,7 +771,7 @@ class VmNetworkingMixin(object):
qubes.firewall.Rule(None, action='accept', specialtarget='dns'),
]
self.testvm1.firewall.save()
self.loop.run_until_complete(self.testvm1.start())
self.loop.run_until_complete(self.start_vm(self.testvm1))
self.assertTrue(self.proxy.is_running())
server = self.loop.run_until_complete(self.testnetvm.run(

26
qubes/tests/integ/network_ipv6.py
View File

@ -75,7 +75,7 @@ class VmIPv6NetworkingMixin(VmNetworkingMixin):
run_netvm_cmd(
"ip6tables -I INPUT -d {} -j ACCEPT".format(self.test_ip6))
# ignore failure
self.run_cmd(self.testnetvm, "pkill dnsmasq")
self.run_cmd(self.testnetvm, "while pkill dnsmasq; do sleep 1; done")
run_netvm_cmd(
"dnsmasq -a {ip} -A /{name}/{ip} -A /{name}/{ip6} -i test0 -z".
format(ip=self.test_ip, ip6=self.test_ip6, name=self.test_name))
@ -84,7 +84,7 @@ class VmIPv6NetworkingMixin(VmNetworkingMixin):
'''
:type self: qubes.tests.SystemTestCase | VmIPv6NetworkingMixin
'''
self.loop.run_until_complete(self.testvm1.start())
self.loop.run_until_complete(self.start_vm(self.testvm1))
self.assertEqual(self.run_cmd(self.testvm1, self.ping6_ip), 0)
self.assertEqual(self.run_cmd(self.testvm1, self.ping6_name), 0)
@ -102,7 +102,7 @@ class VmIPv6NetworkingMixin(VmNetworkingMixin):
self.testvm1.netvm = self.proxy
self.app.save()
self.loop.run_until_complete(self.testvm1.start())
self.loop.run_until_complete(self.start_vm(self.testvm1))
self.assertTrue(self.proxy.is_running())
self.assertEqual(self.run_cmd(self.proxy, self.ping6_ip), 0,
"Ping by IP from ProxyVM failed")
@ -131,7 +131,7 @@ class VmIPv6NetworkingMixin(VmNetworkingMixin):
self.testvm1.netvm = self.proxy
self.app.save()
self.loop.run_until_complete(self.testvm1.start())
self.loop.run_until_complete(self.start_vm(self.testvm1))
self.assertTrue(self.proxy.is_running())
self.assertEqual(self.run_cmd(self.testvm1, self.ping6_ip), 0,
"Ping by IP failed")
@ -187,7 +187,7 @@ class VmIPv6NetworkingMixin(VmNetworkingMixin):
self.testvm1.firewall.rules = [qubes.firewall.Rule(action='drop')]
self.testvm1.firewall.save()
self.loop.run_until_complete(self.testvm1.start())
self.loop.run_until_complete(self.start_vm(self.testvm1))
self.assertTrue(self.proxy.is_running())
server = self.loop.run_until_complete(self.testnetvm.run(
@ -307,9 +307,9 @@ class VmIPv6NetworkingMixin(VmNetworkingMixin):
self.testvm2.netvm = self.proxy
self.app.save()
self.loop.run_until_complete(asyncio.wait([
self.testvm1.start(),
self.testvm2.start()]))
self.loop.run_until_complete(asyncio.gather(
self.start_vm(self.testvm1),
self.start_vm(self.testvm2)))
self.assertNotEqual(self.run_cmd(self.testvm1,
self.ping_cmd.format(target=self.testvm2.ip6)), 0)
@ -335,7 +335,7 @@ class VmIPv6NetworkingMixin(VmNetworkingMixin):
:type self: qubes.tests.SystemTestCase | VmIPv6NetworkingMixin
'''
self.loop.run_until_complete(self.testvm1.start())
self.loop.run_until_complete(self.start_vm(self.testvm1))
self.assertEqual(self.run_cmd(self.testvm1, self.ping6_ip), 0)
# add a simple rule counting packets
@ -345,7 +345,7 @@ class VmIPv6NetworkingMixin(VmNetworkingMixin):
self.loop.run_until_complete(self.testvm1.run_for_stdio(
'ip -6 addr flush dev eth0 && '
'ip -6 addr add {}/128 dev eth0 && '
'ip -6 route add default via {} dev eth0'.format(
'ip -6 route replace default via {} dev eth0'.format(
str(self.testvm1.visible_ip6) + '1',
str(self.testvm1.visible_gateway6)),
user='root'))
@ -369,7 +369,7 @@ class VmIPv6NetworkingMixin(VmNetworkingMixin):
'''
self.testvm1.ip6 = '2000:aaaa:bbbb::1'
self.app.save()
self.loop.run_until_complete(self.testvm1.start())
self.loop.run_until_complete(self.start_vm(self.testvm1))
self.assertEqual(self.run_cmd(self.testvm1, self.ping6_ip), 0)
self.assertEqual(self.run_cmd(self.testvm1, self.ping6_name), 0)
@ -388,7 +388,7 @@ class VmIPv6NetworkingMixin(VmNetworkingMixin):
self.testvm1.netvm = self.proxy
self.app.save()
self.loop.run_until_complete(self.testvm1.start())
self.loop.run_until_complete(self.start_vm(self.testvm1))
self.assertEqual(self.run_cmd(self.testvm1, self.ping6_ip), 0)
self.assertEqual(self.run_cmd(self.testvm1, self.ping6_name), 0)
@ -416,7 +416,7 @@ class VmIPv6NetworkingMixin(VmNetworkingMixin):
qubes.firewall.Rule(None, action='accept', specialtarget='dns'),
]
self.testvm1.firewall.save()
self.loop.run_until_complete(self.testvm1.start())
self.loop.run_until_complete(self.start_vm(self.testvm1))
self.assertTrue(self.proxy.is_running())
server = self.loop.run_until_complete(self.testnetvm.run(

40
qubes/tests/integ/qrexec.py
View File

@ -123,12 +123,12 @@ class TC_00_QrexecMixin(object):
def test_052_qrexec_vm_service_eof(self):
"""Test for EOF transmission VM(src)->VM(dst)"""
self.loop.run_until_complete(asyncio.wait([
self.loop.run_until_complete(asyncio.gather(
self.testvm1.start(),
self.testvm2.start()]))
self.loop.run_until_complete(asyncio.wait([
self.testvm2.start()))
self.loop.run_until_complete(asyncio.gather(
self.wait_for_session(self.testvm1),
self.wait_for_session(self.testvm2)]))
self.wait_for_session(self.testvm2)))
self.create_remote_file(self.testvm2,
'/etc/qubes-rpc/test.EOF',
'#!/bin/sh\n/bin/cat\n')
@ -153,9 +153,9 @@ class TC_00_QrexecMixin(object):
def test_053_qrexec_vm_service_eof_reverse(self):
"""Test for EOF transmission VM(src)<-VM(dst)"""
self.loop.run_until_complete(asyncio.wait([
self.loop.run_until_complete(asyncio.gather(
self.testvm1.start(),
self.testvm2.start()]))
self.testvm2.start()))
self.create_remote_file(self.testvm2, '/etc/qubes-rpc/test.EOF',
'#!/bin/sh\n'
'echo test; exec >&-; cat >/dev/null')
@ -219,9 +219,9 @@ class TC_00_QrexecMixin(object):
self.assertEqual(e.exception.returncode, 3)
def test_065_qrexec_exit_code_vm(self):
self.loop.run_until_complete(asyncio.wait([
self.loop.run_until_complete(asyncio.gather(
self.testvm1.start(),
self.testvm2.start()]))
self.testvm2.start()))
with self.qrexec_policy('test.Retcode', self.testvm1, self.testvm2):
self.create_remote_file(self.testvm2, '/etc/qubes-rpc/test.Retcode',
@ -254,9 +254,9 @@ class TC_00_QrexecMixin(object):
handling anything else.
"""
self.loop.run_until_complete(asyncio.wait([
self.loop.run_until_complete(asyncio.gather(
self.testvm1.start(),
self.testvm2.start()]))
self.testvm2.start()))
self.create_remote_file(self.testvm2, '/etc/qubes-rpc/test.write', '''\
# first write a lot of data
@ -381,9 +381,9 @@ class TC_00_QrexecMixin(object):
def test_080_qrexec_service_argument_allow_default(self):
"""Qrexec service call with argument"""
self.loop.run_until_complete(asyncio.wait([
self.loop.run_until_complete(asyncio.gather(
self.testvm1.start(),
self.testvm2.start()]))
self.testvm2.start()))
self.create_remote_file(self.testvm2, '/etc/qubes-rpc/test.Argument',
'/usr/bin/printf %s "$1"')
@ -397,9 +397,9 @@ class TC_00_QrexecMixin(object):
def test_081_qrexec_service_argument_allow_specific(self):
"""Qrexec service call with argument - allow only specific value"""
self.loop.run_until_complete(asyncio.wait([
self.loop.run_until_complete(asyncio.gather(
self.testvm1.start(),
self.testvm2.start()]))
self.testvm2.start()))
self.create_remote_file(self.testvm2, '/etc/qubes-rpc/test.Argument',
'/usr/bin/printf %s "$1"')
@ -416,9 +416,9 @@ class TC_00_QrexecMixin(object):
def test_082_qrexec_service_argument_deny_specific(self):
"""Qrexec service call with argument - deny specific value"""
self.loop.run_until_complete(asyncio.wait([
self.loop.run_until_complete(asyncio.gather(
self.testvm1.start(),
self.testvm2.start()]))
self.testvm2.start()))
self.create_remote_file(self.testvm2, '/etc/qubes-rpc/test.Argument',
'/usr/bin/printf %s "$1"')
@ -436,9 +436,9 @@ class TC_00_QrexecMixin(object):
def test_083_qrexec_service_argument_specific_implementation(self):
"""Qrexec service call with argument - argument specific
implementatation"""
self.loop.run_until_complete(asyncio.wait([
self.loop.run_until_complete(asyncio.gather(
self.testvm1.start(),
self.testvm2.start()]))
self.testvm2.start()))
self.create_remote_file(self.testvm2,
'/etc/qubes-rpc/test.Argument',
@ -457,9 +457,9 @@ class TC_00_QrexecMixin(object):
def test_084_qrexec_service_argument_extra_env(self):
"""Qrexec service call with argument - extra env variables"""
self.loop.run_until_complete(asyncio.wait([
self.loop.run_until_complete(asyncio.gather(
self.testvm1.start(),
self.testvm2.start()]))
self.testvm2.start()))
self.create_remote_file(self.testvm2, '/etc/qubes-rpc/test.Argument',
'/usr/bin/printf "%s %s" '

24
qubes/tests/integ/vm_qrexec_gui.py
View File

@ -166,9 +166,9 @@ class TC_00_AppVMMixin(object):
self.wait_for_window(title, show=False)
def test_100_qrexec_filecopy(self):
self.loop.run_until_complete(asyncio.wait([
self.loop.run_until_complete(asyncio.gather(
self.testvm1.start(),
self.testvm2.start()]))
self.testvm2.start()))
self.loop.run_until_complete(self.testvm1.run_for_stdio(
'cp /etc/passwd /tmp/passwd'))
@ -195,9 +195,9 @@ class TC_00_AppVMMixin(object):
self.fail('source file got removed')
def test_105_qrexec_filemove(self):
self.loop.run_until_complete(asyncio.wait([
self.loop.run_until_complete(asyncio.gather(
self.testvm1.start(),
self.testvm2.start()]))
self.testvm2.start()))
self.loop.run_until_complete(self.testvm1.run_for_stdio(
'cp /etc/passwd /tmp/passwd'))
@ -254,9 +254,9 @@ class TC_00_AppVMMixin(object):
self.fail('source file got removed')
def test_110_qrexec_filecopy_deny(self):
self.loop.run_until_complete(asyncio.wait([
self.loop.run_until_complete(asyncio.gather(
self.testvm1.start(),
self.testvm2.start()]))
self.testvm2.start()))
with self.qrexec_policy('qubes.Filecopy', self.testvm1, self.testvm2,
allow=False):
@ -275,9 +275,9 @@ class TC_00_AppVMMixin(object):
# The operation should not hang when qrexec-agent is down on target
# machine, see QubesOS/qubes-issues#5347.
self.loop.run_until_complete(asyncio.wait([
self.loop.run_until_complete(asyncio.gather(
self.testvm1.start(),
self.testvm2.start()]))
self.testvm2.start()))
with self.qrexec_policy('qubes.Filecopy', self.testvm1, self.testvm2):
try:
@ -318,9 +318,9 @@ class TC_00_AppVMMixin(object):
@unittest.skipUnless(spawn.find_executable('xdotool'),
"xdotool not installed")
def test_130_qrexec_filemove_disk_full(self):
self.loop.run_until_complete(asyncio.wait([
self.loop.run_until_complete(asyncio.gather(
self.testvm1.start(),
self.testvm2.start()]))
self.testvm2.start()))
self.loop.run_until_complete(self.wait_for_session(self.testvm1))
@ -373,9 +373,9 @@ class TC_00_AppVMMixin(object):
"""Test time synchronization mechanism"""
if self.template.startswith('whonix-'):
self.skipTest('qvm-sync-clock disabled for Whonix VMs')
self.loop.run_until_complete(asyncio.wait([
self.loop.run_until_complete(asyncio.gather(
self.testvm1.start(),
self.testvm2.start(),]))
self.testvm2.start()))
start_time = subprocess.check_output(['date', '-u', '+%s'])
try: