__init__.py 52 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439
  1. # pylint: disable=invalid-name
  2. #
  3. # The Qubes OS Project, https://www.qubes-os.org/
  4. #
  5. # Copyright (C) 2014-2015 Joanna Rutkowska <joanna@invisiblethingslab.com>
  6. # Copyright (C) 2014-2015
  7. # Marek Marczykowski-Górecki <marmarek@invisiblethingslab.com>
  8. # Copyright (C) 2014-2015 Wojtek Porczyk <woju@invisiblethingslab.com>
  9. #
  10. # This library is free software; you can redistribute it and/or
  11. # modify it under the terms of the GNU Lesser General Public
  12. # License as published by the Free Software Foundation; either
  13. # version 2.1 of the License, or (at your option) any later version.
  14. #
  15. # This library is distributed in the hope that it will be useful,
  16. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  17. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  18. # Lesser General Public License for more details.
  19. #
  20. # You should have received a copy of the GNU Lesser General Public
  21. # License along with this library; if not, see <https://www.gnu.org/licenses/>.
  22. #
  23. """
  24. .. warning::
  25. The test suite hereby claims any domain whose name starts with
  26. :py:data:`VMPREFIX` as fair game. This is needed to enforce sane
  27. test executing environment. If you have domains named ``test-*``,
  28. don't run the tests.
  29. """
  30. import asyncio
  31. import collections
  32. import functools
  33. import logging
  34. import os
  35. import pathlib
  36. import shlex
  37. import shutil
  38. import subprocess
  39. import sys
  40. import tempfile
  41. import time
  42. import traceback
  43. import unittest
  44. import warnings
  45. from distutils import spawn
  46. import gc
  47. import lxml.etree
  48. import pkg_resources
  49. import qubes
  50. import qubes.api
  51. import qubes.api.admin
  52. import qubes.api.internal
  53. import qubes.api.misc
  54. import qubes.backup
  55. import qubes.config
  56. import qubes.devices
  57. import qubes.events
  58. import qubes.exc
  59. import qubes.ext.pci
  60. import qubes.vm.standalonevm
  61. import qubes.vm.templatevm
  62. XMLPATH = '/var/lib/qubes/qubes-test.xml'
  63. CLASS_XMLPATH = '/var/lib/qubes/qubes-class-test.xml'
  64. TEMPLATE = 'fedora-23'
  65. VMPREFIX = 'test-inst-'
  66. CLSVMPREFIX = 'test-cls-'
  67. if 'DEFAULT_LVM_POOL' in os.environ.keys():
  68. DEFAULT_LVM_POOL = os.environ['DEFAULT_LVM_POOL']
  69. else:
  70. DEFAULT_LVM_POOL = 'qubes_dom0/pool00'
  71. POOL_CONF = {'name': 'test-lvm',
  72. 'driver': 'lvm_thin',
  73. 'volume_group': DEFAULT_LVM_POOL.split('/')[0],
  74. 'thin_pool': DEFAULT_LVM_POOL.split('/')[1]}
  75. #: :py:obj:`True` if running in dom0, :py:obj:`False` otherwise
  76. in_dom0 = False
  77. #: :py:obj:`False` if outside of git repo,
  78. #: path to root of the directory otherwise
  79. in_git = False
  80. try:
  81. import libvirt
  82. libvirt.openReadOnly(qubes.config.defaults['libvirt_uri']).close()
  83. in_dom0 = True
  84. except libvirt.libvirtError:
  85. pass
  86. if in_dom0:
  87. import libvirtaio
  88. libvirt_event_impl = libvirtaio.virEventRegisterAsyncIOImpl()
  89. else:
  90. libvirt_event_impl = None
  91. try:
  92. in_git = subprocess.check_output(
  93. ['git', 'rev-parse', '--show-toplevel']).decode().strip()
  94. qubes.log.LOGPATH = '/tmp'
  95. qubes.log.LOGFILE = '/tmp/qubes.log'
  96. except subprocess.CalledProcessError:
  97. # git returned nonzero, we are outside git repo
  98. pass
  99. except OSError:
  100. # command not found; let's assume we're outside
  101. pass
  102. ha_syslog = None
  103. def skipUnlessDom0(test_item):
  104. '''Decorator that skips test outside dom0.
  105. Some tests (especially integration tests) have to be run in more or less
  106. working dom0. This is checked by connecting to libvirt.
  107. '''
  108. return unittest.skipUnless(in_dom0, 'outside dom0')(test_item)
  109. def skipUnlessGit(test_item):
  110. '''Decorator that skips test outside git repo.
  111. There are very few tests that an be run only in git. One example is
  112. correctness of example code that won't get included in RPM.
  113. '''
  114. return unittest.skipUnless(in_git, 'outside git tree')(test_item)
  115. def skipUnlessEnv(varname):
  116. '''Decorator generator for skipping tests without environment variable set.
  117. Some tests require working X11 display, like those using GTK library, which
  118. segfaults without connection to X.
  119. Other require their own, custom variables.
  120. '''
  121. return unittest.skipUnless(os.getenv(varname), 'no {} set'.format(varname))
  122. class TestEmitter(qubes.events.Emitter):
  123. '''Dummy event emitter which records events fired on it.
  124. Events are counted in :py:attr:`fired_events` attribute, which is
  125. :py:class:`collections.Counter` instance. For each event, ``(event, args,
  126. kwargs)`` object is counted. *event* is event name (a string), *args* is
  127. tuple with positional arguments and *kwargs* is sorted tuple of items from
  128. keyword arguments.
  129. >>> emitter = TestEmitter()
  130. >>> emitter.fired_events
  131. Counter()
  132. >>> emitter.fire_event('event', spam='eggs', foo='bar')
  133. >>> emitter.fired_events
  134. Counter({('event', (1, 2, 3), (('foo', 'bar'), ('spam', 'eggs'))): 1})
  135. '''
  136. def __init__(self, *args, **kwargs):
  137. super(TestEmitter, self).__init__(*args, **kwargs)
  138. #: :py:class:`collections.Counter` instance
  139. self.fired_events = collections.Counter()
  140. def fire_event(self, event, **kwargs):
  141. effects = super(TestEmitter, self).fire_event(event, **kwargs)
  142. ev_kwargs = frozenset(
  143. (key,
  144. frozenset(value.items()) if isinstance(value, dict)
  145. else tuple(value) if isinstance(value, list)
  146. else value)
  147. for key, value in kwargs.items()
  148. )
  149. self.fired_events[(event, ev_kwargs)] += 1
  150. return effects
  151. @asyncio.coroutine
  152. def fire_event_async(self, event, pre_event=False, **kwargs):
  153. effects = yield from super(TestEmitter, self).fire_event_async(
  154. event, pre_event=pre_event, **kwargs)
  155. ev_kwargs = frozenset(
  156. (key,
  157. frozenset(value.items()) if isinstance(value, dict) else value)
  158. for key, value in kwargs.items()
  159. )
  160. self.fired_events[(event, ev_kwargs)] += 1
  161. return effects
  162. def expectedFailureIfTemplate(templates):
  163. """
  164. Decorator for marking specific test as expected to fail only for some
  165. templates. Template name is compared as substring, so 'whonix' will
  166. handle both 'whonix-ws' and 'whonix-gw'.
  167. templates can be either a single string, or an iterable
  168. """
  169. def decorator(func):
  170. @functools.wraps(func)
  171. def wrapper(self, *args, **kwargs):
  172. template = self.template
  173. if isinstance(templates, str):
  174. should_expect_fail = template in templates
  175. else:
  176. should_expect_fail = any([template in x for x in templates])
  177. if should_expect_fail:
  178. try:
  179. func(self, *args, **kwargs)
  180. except Exception:
  181. raise unittest.case._ExpectedFailure(sys.exc_info())
  182. raise unittest.case._UnexpectedSuccess()
  183. else:
  184. # Call directly:
  185. func(self, *args, **kwargs)
  186. return wrapper
  187. return decorator
  188. def wait_on_fail(func):
  189. """Test decorator for debugging. It pause test execution on failure and wait
  190. for user input. It's useful to manually inspect system state just after test
  191. fails, before executing any cleanup.
  192. Usage: decorate a test you are debugging.
  193. DO IT ONLY TEMPORARILY, DO NOT COMMIT!
  194. """
  195. @functools.wraps(func)
  196. def wrapper(self, *args, **kwargs):
  197. try:
  198. func(self, *args, **kwargs)
  199. except:
  200. print('FAIL\n')
  201. traceback.print_exc()
  202. print('Press return to continue:', end='')
  203. sys.stdout.flush()
  204. reader = asyncio.StreamReader(loop=self.loop)
  205. transport, protocol = self.loop.run_until_complete(
  206. self.loop.connect_read_pipe(lambda: asyncio.StreamReaderProtocol(reader),
  207. sys.stdin))
  208. self.loop.run_until_complete(reader.readline())
  209. raise
  210. return wrapper
  211. class _AssertNotRaisesContext(object):
  212. """A context manager used to implement TestCase.assertNotRaises methods.
  213. Stolen from unittest and hacked. Regexp support stripped.
  214. """ # pylint: disable=too-few-public-methods
  215. def __init__(self, expected, test_case, expected_regexp=None):
  216. if expected_regexp is not None:
  217. raise NotImplementedError('expected_regexp is unsupported')
  218. self.expected = expected
  219. self.exception = None
  220. self.failureException = test_case.failureException
  221. def __enter__(self):
  222. return self
  223. def __exit__(self, exc_type, exc_value, tb):
  224. if exc_type is None:
  225. return True
  226. if issubclass(exc_type, self.expected):
  227. raise self.failureException(
  228. "{!r} raised, traceback:\n{!s}".format(
  229. exc_value, ''.join(traceback.format_tb(tb))))
  230. else:
  231. # pass through
  232. return False
  233. self.exception = exc_value # store for later retrieval
  234. class _QrexecPolicyContext(object):
  235. '''Context manager for SystemTestCase.qrexec_policy'''
  236. def __init__(self, service, source, destination, allow=True, action=None):
  237. try:
  238. source = source.name
  239. except AttributeError:
  240. pass
  241. try:
  242. destination = destination.name
  243. except AttributeError:
  244. pass
  245. self._filename = pathlib.Path('/etc/qubes-rpc/policy') / service
  246. if action is None:
  247. action = 'allow' if allow else 'deny'
  248. self._rule = '{} {} {}\n'.format(source, destination, action)
  249. self._did_create = False
  250. self._handle = None
  251. def load(self):
  252. if self._handle is None:
  253. try:
  254. self._handle = self._filename.open('r+')
  255. except FileNotFoundError:
  256. self._handle = self._filename.open('w+')
  257. self._did_create = True
  258. self._handle.seek(0)
  259. return self._handle.readlines()
  260. def save(self, rules):
  261. assert self._handle is not None
  262. self._handle.truncate(0)
  263. self._handle.seek(0)
  264. self._handle.write(''.join(rules))
  265. self._handle.flush()
  266. def close(self):
  267. assert self._handle is not None
  268. self._handle.close()
  269. self._handle = None
  270. def __enter__(self):
  271. rules = self.load()
  272. rules.insert(0, self._rule)
  273. self.save(rules)
  274. return self
  275. def __exit__(self, exc_type, exc_value, tb):
  276. if not self._did_create:
  277. try:
  278. rules = self.load()
  279. rules.remove(self._rule)
  280. self.save(rules)
  281. finally:
  282. self.close()
  283. else:
  284. self.close()
  285. self._filename.unlink()
  286. class substitute_entry_points(object):
  287. '''Monkey-patch pkg_resources to substitute one group in iter_entry_points
  288. This is for testing plugins, like device classes.
  289. :param str group: The group that is to be overloaded.
  290. :param str tempgroup: The substitute group.
  291. Inside this context, if one iterates over entry points in overloaded group,
  292. the iteration actually happens over the other group.
  293. This context manager is stackable. To substitute more than one entry point
  294. group, just nest two contexts.
  295. ''' # pylint: disable=invalid-name
  296. def __init__(self, group, tempgroup):
  297. self.group = group
  298. self.tempgroup = tempgroup
  299. self._orig_iter_entry_points = None
  300. def _iter_entry_points(self, group, *args, **kwargs):
  301. if group == self.group:
  302. group = self.tempgroup
  303. return self._orig_iter_entry_points(group, *args, **kwargs)
  304. def __enter__(self):
  305. self._orig_iter_entry_points = pkg_resources.iter_entry_points
  306. pkg_resources.iter_entry_points = self._iter_entry_points
  307. return self
  308. def __exit__(self, exc_type, exc_value, tb):
  309. pkg_resources.iter_entry_points = self._orig_iter_entry_points
  310. self._orig_iter_entry_points = None
  311. class QubesTestCase(unittest.TestCase):
  312. '''Base class for Qubes unit tests.
  313. '''
  314. def __init__(self, *args, **kwargs):
  315. super(QubesTestCase, self).__init__(*args, **kwargs)
  316. self.longMessage = True
  317. self.log = logging.getLogger('{}.{}.{}'.format(
  318. self.__class__.__module__,
  319. self.__class__.__name__,
  320. self._testMethodName))
  321. self.addTypeEqualityFunc(qubes.devices.DeviceManager,
  322. self.assertDevicesEqual)
  323. self.loop = None
  324. def __str__(self):
  325. return '{}/{}/{}'.format(
  326. self.__class__.__module__,
  327. self.__class__.__name__,
  328. self._testMethodName)
  329. def setUp(self):
  330. super().setUp()
  331. self.addCleanup(self.cleanup_gc)
  332. self.loop = asyncio.get_event_loop()
  333. self.addCleanup(self.cleanup_loop)
  334. self.addCleanup(self.cleanup_traceback)
  335. def cleanup_traceback(self):
  336. '''Remove local variables reference from tracebacks to allow garbage
  337. collector to clean all Qubes*() objects, otherwise file descriptors
  338. held by them will leak'''
  339. exc_infos = [e for test_case, e in self._outcome.errors
  340. if test_case is self]
  341. if self._outcome.expectedFailure:
  342. exc_infos.append(self._outcome.expectedFailure)
  343. for exc_info in exc_infos:
  344. if exc_info is None:
  345. continue
  346. ex = exc_info[1]
  347. while ex is not None:
  348. if isinstance(ex, qubes.exc.QubesVMError):
  349. ex.vm = None
  350. traceback.clear_frames(ex.__traceback__)
  351. ex = ex.__context__
  352. def cleanup_gc(self):
  353. gc.collect()
  354. leaked = [obj for obj in gc.get_objects() + gc.garbage
  355. if isinstance(obj,
  356. (qubes.Qubes, qubes.vm.BaseVM,
  357. libvirt.virConnect, libvirt.virDomain))]
  358. if leaked:
  359. try:
  360. import objgraph
  361. objgraph.show_backrefs(leaked,
  362. max_depth=15, extra_info=extra_info,
  363. filename='/tmp/objgraph-{}.png'.format(self.id()))
  364. except ImportError:
  365. pass
  366. # do not keep leaked object references in locals()
  367. leaked = bool(leaked)
  368. assert not leaked
  369. def cleanup_loop(self):
  370. '''Check if the loop is empty'''
  371. # XXX BEWARE this is touching undocumented, implementation-specific
  372. # attributes of the loop. This is most certainly unsupported and likely
  373. # will break when messing with: Python version, kernel family, loop
  374. # implementation, a combination thereof, or other things.
  375. # KEYWORDS for searching:
  376. # win32, SelectorEventLoop, ProactorEventLoop, uvloop, gevent
  377. global libvirt_event_impl
  378. # really destroy all objects that could have used loop and/or libvirt
  379. gc.collect()
  380. # Check for unfinished libvirt business.
  381. if libvirt_event_impl is not None:
  382. try:
  383. self.loop.run_until_complete(asyncio.wait_for(
  384. libvirt_event_impl.drain(), timeout=4))
  385. except asyncio.TimeoutError:
  386. raise AssertionError('libvirt event impl drain timeout')
  387. # this is stupid, but apparently it requires two passes
  388. # to cleanup SIGCHLD handlers
  389. self.loop.stop()
  390. self.loop.run_forever()
  391. self.loop.stop()
  392. self.loop.run_forever()
  393. # Check there are no Tasks left.
  394. assert not self.loop._ready
  395. assert not self.loop._scheduled
  396. # Check the loop watches no descriptors.
  397. # NOTE the loop has a pipe for self-interrupting, created once per
  398. # lifecycle, and it is unwatched only at loop.close(); so we cannot just
  399. # check selector for non-emptiness
  400. assert len(self.loop._selector.get_map()) \
  401. == int(self.loop._ssock is not None)
  402. del self.loop
  403. def assertNotRaises(self, excClass, callableObj=None, *args, **kwargs):
  404. """Fail if an exception of class excClass is raised
  405. by callableObj when invoked with arguments args and keyword
  406. arguments kwargs. If a different type of exception is
  407. raised, it will not be caught, and the test case will be
  408. deemed to have suffered an error, exactly as for an
  409. unexpected exception.
  410. If called with callableObj omitted or None, will return a
  411. context object used like this::
  412. with self.assertRaises(SomeException):
  413. do_something()
  414. The context manager keeps a reference to the exception as
  415. the 'exception' attribute. This allows you to inspect the
  416. exception after the assertion::
  417. with self.assertRaises(SomeException) as cm:
  418. do_something()
  419. the_exception = cm.exception
  420. self.assertEqual(the_exception.error_code, 3)
  421. """
  422. context = _AssertNotRaisesContext(excClass, self)
  423. if callableObj is None:
  424. return context
  425. with context:
  426. callableObj(*args, **kwargs)
  427. def assertXMLEqual(self, xml1, xml2, msg=''):
  428. '''Check for equality of two XML objects.
  429. :param xml1: first element
  430. :param xml2: second element
  431. :type xml1: :py:class:`lxml.etree._Element`
  432. :type xml2: :py:class:`lxml.etree._Element`
  433. '''
  434. self.assertEqual(xml1.tag, xml2.tag)
  435. msg += '/' + str(xml1.tag)
  436. if xml1.text is not None and xml2.text is not None:
  437. self.assertEqual(xml1.text.strip(), xml2.text.strip(), msg)
  438. else:
  439. self.assertEqual(xml1.text, xml2.text, msg)
  440. self.assertCountEqual(xml1.keys(), xml2.keys(), msg)
  441. for key in xml1.keys():
  442. self.assertEqual(xml1.get(key), xml2.get(key), msg)
  443. self.assertEqual(len(xml1), len(xml2), msg + ' children count')
  444. for child1, child2 in zip(xml1, xml2):
  445. self.assertXMLEqual(child1, child2, msg=msg)
  446. def assertDevicesEqual(self, devices1, devices2, msg=None):
  447. self.assertEqual(devices1.keys(), devices2.keys(), msg)
  448. for dev_class in devices1.keys():
  449. self.assertEqual(
  450. [str(dev) for dev in devices1[dev_class]],
  451. [str(dev) for dev in devices2[dev_class]],
  452. "Devices of class {} differs{}".format(
  453. dev_class, (": " + msg) if msg else "")
  454. )
  455. def assertEventFired(self, subject, event, kwargs=None):
  456. '''Check whether event was fired on given emitter and fail if it did
  457. not.
  458. :param subject: emitter which is being checked
  459. :type emitter: :py:class:`TestEmitter`
  460. :param str event: event identifier
  461. :param dict kwargs: when given, all items must appear in kwargs passed \
  462. to an event
  463. '''
  464. will_not_match = object()
  465. for ev, ev_kwargs in subject.fired_events:
  466. if ev != event:
  467. continue
  468. if kwargs is not None:
  469. ev_kwargs = dict(ev_kwargs)
  470. if any(ev_kwargs.get(k, will_not_match) != v
  471. for k, v in kwargs.items()):
  472. continue
  473. return
  474. self.fail('event {!r} {}did not fire on {!r}'.format(
  475. event, ('' if kwargs is None else '{!r} '.format(kwargs)), subject))
  476. def assertEventNotFired(self, subject, event, kwargs=None):
  477. '''Check whether event was fired on given emitter. Fail if it did.
  478. :param subject: emitter which is being checked
  479. :type emitter: :py:class:`TestEmitter`
  480. :param str event: event identifier
  481. :param list kwargs: when given, all items must appear in kwargs passed \
  482. to an event
  483. '''
  484. will_not_match = object()
  485. for ev, ev_kwargs in subject.fired_events:
  486. if ev != event:
  487. continue
  488. if kwargs is not None:
  489. ev_kwargs = dict(ev_kwargs)
  490. if any(ev_kwargs.get(k, will_not_match) != v
  491. for k, v in kwargs.items()):
  492. continue
  493. self.fail('event {!r} {}did fire on {!r}'.format(
  494. event,
  495. ('' if kwargs is None else '{!r} '.format(kwargs)),
  496. subject))
  497. return
  498. def assertXMLIsValid(self, xml, file=None, schema=None):
  499. '''Check whether given XML fulfills Relax NG schema.
  500. Schema can be given in a couple of ways:
  501. - As separate file. This is most common, and also the only way to
  502. handle file inclusion. Call with file name as second argument.
  503. - As string containing actual schema. Put that string in *schema*
  504. keyword argument.
  505. :param lxml.etree._Element xml: XML element instance to check
  506. :param str file: filename of Relax NG schema
  507. :param str schema: optional explicit schema string
  508. ''' # pylint: disable=redefined-builtin
  509. if schema is not None and file is None:
  510. relaxng = schema
  511. if isinstance(relaxng, str):
  512. relaxng = lxml.etree.XML(relaxng)
  513. # pylint: disable=protected-access
  514. if isinstance(relaxng, lxml.etree._Element):
  515. relaxng = lxml.etree.RelaxNG(relaxng)
  516. elif file is not None and schema is None:
  517. if not os.path.isabs(file):
  518. basedirs = ['/usr/share/doc/qubes/relaxng']
  519. if in_git:
  520. basedirs.insert(0, os.path.join(in_git, 'relaxng'))
  521. for basedir in basedirs:
  522. abspath = os.path.join(basedir, file)
  523. if os.path.exists(abspath):
  524. file = abspath
  525. break
  526. relaxng = lxml.etree.RelaxNG(file=file)
  527. else:
  528. raise TypeError("There should be excactly one of 'file' and "
  529. "'schema' arguments specified.")
  530. # We have to be extra careful here in case someone messed up with
  531. # self.failureException. It should by default be AssertionError, just
  532. # what is spewed by RelaxNG(), but who knows what might happen.
  533. try:
  534. relaxng.assert_(xml)
  535. except self.failureException:
  536. raise
  537. except AssertionError as e:
  538. self.fail(str(e))
  539. @staticmethod
  540. def make_vm_name(name, class_teardown=False):
  541. if class_teardown:
  542. return CLSVMPREFIX + name
  543. else:
  544. return VMPREFIX + name
  545. class SystemTestCase(QubesTestCase):
  546. """
  547. Mixin for integration tests. All the tests here should use self.app
  548. object and when need qubes.xml path - should use :py:data:`XMLPATH`
  549. defined in this file.
  550. Every VM created by test, must use :py:meth:`SystemTestCase.make_vm_name`
  551. for VM name.
  552. By default self.app represents empty collection, if anything is needed
  553. there from the real collection it can be imported from self.host_app in
  554. :py:meth:`SystemTestCase.setUp`. But *can not be modified* in any way -
  555. this include both changing attributes in
  556. :py:attr:`SystemTestCase.host_app` and modifying files of such imported
  557. VM. If test need to make some modification, it must clone the VM first.
  558. If some group of tests needs class-wide initialization, first of all the
  559. author should consider if it is really needed. But if so, setUpClass can
  560. be used to create Qubes(CLASS_XMLPATH) object and create/import required
  561. stuff there. VMs created in :py:meth:`TestCase.setUpClass` should
  562. use self.make_vm_name('...', class_teardown=True) for name creation.
  563. Such (group of) test need to take care about
  564. :py:meth:`TestCase.tearDownClass` implementation itself.
  565. """
  566. # noinspection PyAttributeOutsideInit
  567. def setUp(self):
  568. if not in_dom0:
  569. self.skipTest('outside dom0')
  570. super(SystemTestCase, self).setUp()
  571. self.remove_test_vms()
  572. global ha_syslog
  573. if ha_syslog is None:
  574. ha_syslog = logging.handlers.SysLogHandler('/dev/log')
  575. ha_syslog.setFormatter(
  576. logging.Formatter('%(name)s[%(process)d]: %(message)s'))
  577. logging.root.addHandler(ha_syslog)
  578. self.log.critical('starting')
  579. # need some information from the real qubes.xml - at least installed
  580. # templates; should not be used for testing, only to initialize self.app
  581. self.host_app = qubes.Qubes(os.path.join(
  582. qubes.config.qubes_base_dir,
  583. qubes.config.system_path['qubes_store_filename']))
  584. if os.path.exists(CLASS_XMLPATH):
  585. shutil.copy(CLASS_XMLPATH, XMLPATH)
  586. else:
  587. shutil.copy(self.host_app.store, XMLPATH)
  588. self.app = qubes.Qubes(XMLPATH)
  589. os.environ['QUBES_XML_PATH'] = XMLPATH
  590. self.app.register_event_handlers()
  591. self.qubesd = self.loop.run_until_complete(
  592. qubes.api.create_servers(
  593. qubes.api.admin.QubesAdminAPI,
  594. qubes.api.internal.QubesInternalAPI,
  595. qubes.api.misc.QubesMiscAPI,
  596. app=self.app, debug=True))
  597. self.addCleanup(self.cleanup_app)
  598. self.app.add_handler('domain-delete', self.close_qdb_on_remove)
  599. def close_qdb_on_remove(self, app, event, vm, **kwargs):
  600. # only close QubesDB connection, do not perform other (destructive)
  601. # actions of vm.close()
  602. if vm._qdb_connection_watch is not None:
  603. asyncio.get_event_loop().remove_reader(
  604. vm._qdb_connection_watch.watch_fd())
  605. vm._qdb_connection_watch.close()
  606. vm._qdb_connection_watch = None
  607. def cleanup_app(self):
  608. self.remove_test_vms()
  609. server = None
  610. for server in self.qubesd:
  611. for sock in server.sockets:
  612. os.unlink(sock.getsockname())
  613. server.close()
  614. del server
  615. # close all existing connections, especially this will interrupt
  616. # running admin.Events calls, which do keep reference to Qubes() and
  617. # libvirt connection
  618. conn = None
  619. for conn in qubes.api.QubesDaemonProtocol.connections:
  620. if conn.transport:
  621. conn.transport.abort()
  622. del conn
  623. self.loop.run_until_complete(asyncio.wait([
  624. server.wait_closed() for server in self.qubesd]))
  625. del self.qubesd
  626. # remove all references to any complex qubes objects, to release
  627. # resources - most importantly file descriptors; this object will live
  628. # during the whole test run, but all the file descriptors would be
  629. # depleted earlier
  630. self.app.close()
  631. self.host_app.close()
  632. del self.app
  633. del self.host_app
  634. for attr in dir(self):
  635. obj_type = type(getattr(self, attr))
  636. if obj_type.__module__.startswith('qubes'):
  637. delattr(self, attr)
  638. # then trigger garbage collector to really destroy those objects
  639. gc.collect()
  640. def init_default_template(self, template=None):
  641. if template is None:
  642. template = self.host_app.default_template
  643. elif isinstance(template, str):
  644. template = self.host_app.domains[template]
  645. self.app.default_template = str(template)
  646. def init_networking(self):
  647. if not self.app.default_template:
  648. self.skipTest('Default template required for testing networking')
  649. default_netvm = self.host_app.default_netvm
  650. # if testing Whonix Workstation based VMs, try to use sys-whonix instead
  651. if self.app.default_template.name.startswith('whonix-ws'):
  652. if 'sys-whonix' in self.host_app.domains:
  653. default_netvm = self.host_app.domains['sys-whonix']
  654. if default_netvm is None:
  655. self.skipTest('Default netvm required')
  656. if not default_netvm.is_running():
  657. self.skipTest('VM {} required to be running'.format(
  658. default_netvm.name))
  659. self.app.default_netvm = str(default_netvm)
  660. def _find_pool(self, volume_group, thin_pool):
  661. ''' Returns the pool matching the specified ``volume_group`` &
  662. ``thin_pool``, or None.
  663. '''
  664. pools = [p for p in self.app.pools
  665. if issubclass(p.__class__, qubes.storage.lvm.ThinPool)]
  666. for pool in pools:
  667. if pool.volume_group == volume_group \
  668. and pool.thin_pool == thin_pool:
  669. return pool
  670. return None
  671. def init_lvm_pool(self):
  672. volume_group, thin_pool = DEFAULT_LVM_POOL.split('/', 1)
  673. path = "/dev/mapper/{!s}-{!s}".format(volume_group, thin_pool)
  674. if not os.path.exists(path):
  675. self.skipTest('LVM thin pool {!r} does not exist'.
  676. format(DEFAULT_LVM_POOL))
  677. self.pool = self._find_pool(volume_group, thin_pool)
  678. if not self.pool:
  679. self.pool = self.loop.run_until_complete(
  680. self.app.add_pool(**POOL_CONF))
  681. self.created_pool = True
  682. def _remove_vm_qubes(self, vm):
  683. vmname = vm.name
  684. app = vm.app
  685. try:
  686. del app.domains[vm.qid]
  687. except KeyError:
  688. pass
  689. try:
  690. self.loop.run_until_complete(vm.remove_from_disk())
  691. except: # pylint: disable=bare-except
  692. pass
  693. vm.close()
  694. del vm
  695. app.save()
  696. del app
  697. # Now ensure it really went away. This may not have happened,
  698. # for example if vm.libvirt_domain malfunctioned.
  699. try:
  700. conn = libvirt.open(qubes.config.defaults['libvirt_uri'])
  701. except: # pylint: disable=bare-except
  702. pass
  703. else:
  704. try:
  705. dom = conn.lookupByName(vmname)
  706. except: # pylint: disable=bare-except
  707. pass
  708. else:
  709. self._remove_vm_libvirt(dom)
  710. conn.close()
  711. self._remove_vm_disk(vmname)
  712. @staticmethod
  713. def _remove_vm_libvirt(dom):
  714. try:
  715. dom.destroy()
  716. except libvirt.libvirtError: # not running
  717. pass
  718. dom.undefine()
  719. @staticmethod
  720. def _remove_vm_disk(vmname):
  721. for dirspec in (
  722. 'qubes_appvms_dir',
  723. 'qubes_templates_dir'):
  724. dirpath = os.path.join(qubes.config.qubes_base_dir,
  725. qubes.config.system_path[dirspec], vmname)
  726. if os.path.exists(dirpath):
  727. if os.path.isdir(dirpath):
  728. shutil.rmtree(dirpath)
  729. else:
  730. os.unlink(dirpath)
  731. @staticmethod
  732. def _remove_vm_disk_lvm(prefix=VMPREFIX):
  733. ''' Remove LVM volumes with given prefix
  734. This is "a bit" drastic, as it removes volumes regardless of volume
  735. group, thin pool etc. But we assume no important data on test system.
  736. '''
  737. try:
  738. volumes = subprocess.check_output(
  739. ['lvs', '--noheadings', '-o', 'vg_name,name',
  740. '--separator', '/']).decode()
  741. if ('/vm-' + prefix) not in volumes:
  742. return
  743. subprocess.check_call(['sudo', 'lvremove', '-f'] +
  744. [vol.strip() for vol in volumes.splitlines()
  745. if ('/vm-' + prefix) in vol],
  746. stdout=subprocess.DEVNULL)
  747. except subprocess.CalledProcessError:
  748. pass
  749. def remove_vms(self, vms):
  750. vms = list(vms)
  751. if not vms:
  752. return
  753. # workaround for https://phabricator.whonix.org/T930
  754. # unregister all the VMs from sys-whonix, otherwise it will start them
  755. # again (possibly in further test)
  756. if 'whonix' in self.app.default_netvm.name:
  757. for vm in vms:
  758. try:
  759. self.loop.run_until_complete(
  760. self.app.default_netvm.run_service_for_stdio(
  761. 'whonix.NewStatus+{}_shutdown'.format(vm.name)))
  762. except:
  763. pass
  764. locked_vms = set()
  765. # first take startup lock
  766. for vm in vms:
  767. self.loop.run_until_complete(vm.startup_lock.acquire())
  768. locked_vms.add(vm)
  769. # first kill all the domains, to avoid side effects of changing netvm
  770. for vm in vms:
  771. try:
  772. # XXX .is_running() may throw libvirtError if undefined
  773. if vm.is_running():
  774. self.loop.run_until_complete(vm._kill_locked())
  775. except: # pylint: disable=bare-except
  776. pass
  777. # break dependencies
  778. for vm in vms:
  779. vm.default_dispvm = None
  780. vm.netvm = None
  781. # take app instance from any VM to be removed
  782. app = vms[0].app
  783. if app.default_dispvm in vms:
  784. app.default_dispvm = None
  785. if app.default_netvm in vms:
  786. app.default_netvm = None
  787. del app
  788. # then remove in reverse topological order (wrt template), using naive
  789. # algorithm
  790. # this heavily depends on lack of template loops, but those are
  791. # impossible
  792. while vms:
  793. vm = vms.pop(0)
  794. # make sure that all connected VMs are going to be removed,
  795. # otherwise this will loop forever
  796. child_vms = list(getattr(vm, 'appvms', []))
  797. assert all(x in vms for x in child_vms)
  798. if child_vms:
  799. # if still something use this VM, put it at the end of queue
  800. # and try next one
  801. vms.append(vm)
  802. continue
  803. self._remove_vm_qubes(vm)
  804. # release startup_lock, if anything was waiting at vm.start(),
  805. # it will detect the VM is gone
  806. for vm in locked_vms:
  807. vm.startup_lock.release()
  808. def remove_test_vms(self, xmlpath=XMLPATH, prefix=VMPREFIX):
  809. '''Aggressively remove any domain that has name in testing namespace.
  810. :param prefix: name prefix of VMs to remove, can be a list of prefixes
  811. '''
  812. if isinstance(prefix, str):
  813. prefixes = [prefix]
  814. else:
  815. prefixes = prefix
  816. del prefix
  817. # first, remove them Qubes-way
  818. if os.path.exists(xmlpath):
  819. try:
  820. try:
  821. app = self.app
  822. except AttributeError:
  823. app = qubes.Qubes(xmlpath)
  824. try:
  825. host_app = self.host_app
  826. except AttributeError:
  827. host_app = qubes.Qubes()
  828. self.remove_vms([vm for vm in app.domains
  829. if any(vm.name.startswith(prefix) for prefix in prefixes) or
  830. (isinstance(vm, qubes.vm.dispvm.DispVM) and vm.name
  831. not in host_app.domains)])
  832. if not hasattr(self, 'host_app'):
  833. host_app.close()
  834. del host_app
  835. if not hasattr(self, 'app'):
  836. app.close()
  837. del app
  838. except qubes.exc.QubesException:
  839. pass
  840. os.unlink(xmlpath)
  841. # now remove what was only in libvirt
  842. conn = libvirt.open(qubes.config.defaults['libvirt_uri'])
  843. for dom in conn.listAllDomains():
  844. if any(dom.name().startswith(prefix) for prefix in prefixes):
  845. self._remove_vm_libvirt(dom)
  846. conn.close()
  847. # finally remove anything that is left on disk
  848. vmnames = set()
  849. for dirspec in (
  850. 'qubes_appvms_dir',
  851. 'qubes_templates_dir'):
  852. dirpath = os.path.join(qubes.config.qubes_base_dir,
  853. qubes.config.system_path[dirspec])
  854. if not os.path.exists(dirpath):
  855. continue
  856. for name in os.listdir(dirpath):
  857. if any(name.startswith(prefix) for prefix in prefixes):
  858. vmnames.add(name)
  859. for vmname in vmnames:
  860. self._remove_vm_disk(vmname)
  861. for prefix in prefixes:
  862. self._remove_vm_disk_lvm(prefix)
  863. def qrexec_policy(self, service, source, destination, allow=True,
  864. action=None):
  865. """
  866. Allow qrexec calls for duration of the test
  867. :param service: service name
  868. :param source: source VM name
  869. :param destination: destination VM name
  870. :param allow: add rule with 'allow' action, otherwise 'deny'
  871. :param action: custom action, if specified *allow* argument is ignored
  872. :return:
  873. """
  874. return _QrexecPolicyContext(service, source, destination,
  875. allow=allow, action=action)
  876. @asyncio.coroutine
  877. def wait_for_window_hide_coro(self, title, winid, timeout=30):
  878. """
  879. Wait for window do disappear
  880. :param winid: window id
  881. :return:
  882. """
  883. wait_count = 0
  884. while subprocess.call(['xdotool', 'getwindowname', str(winid)],
  885. stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT) == 0:
  886. wait_count += 1
  887. if wait_count > timeout * 10:
  888. self.fail("Timeout while waiting for {}({}) window to "
  889. "disappear".format(title, winid))
  890. yield from asyncio.sleep(0.1)
  891. @asyncio.coroutine
  892. def wait_for_window_coro(self, title, search_class=False, timeout=30,
  893. show=True):
  894. """
  895. Wait for a window with a given title. Depending on show parameter,
  896. it will wait for either window to show or to disappear.
  897. :param title: title of the window to wait for
  898. :param timeout: timeout of the operation, in seconds
  899. :param show: if True - wait for the window to be visible,
  900. otherwise - to not be visible
  901. :param search_class: search based on window class instead of title
  902. :return: window id of found window, if show=True
  903. """
  904. xdotool_search = ['xdotool', 'search', '--onlyvisible']
  905. if search_class:
  906. xdotool_search.append('--class')
  907. else:
  908. xdotool_search.append('--name')
  909. if show:
  910. xdotool_search.append('--sync')
  911. if not show:
  912. try:
  913. winid = subprocess.check_output(xdotool_search + [title],
  914. stderr=subprocess.DEVNULL).decode()
  915. except subprocess.CalledProcessError:
  916. # already gone
  917. return
  918. yield from self.wait_for_window_hide_coro(winid, title,
  919. timeout=timeout)
  920. return
  921. winid = None
  922. while not winid:
  923. p = yield from asyncio.create_subprocess_exec(
  924. *xdotool_search, title,
  925. stderr=subprocess.DEVNULL, stdout=subprocess.PIPE)
  926. try:
  927. (winid, _) = yield from asyncio.wait_for(
  928. p.communicate(), timeout)
  929. # don't check exit code, getting winid on stdout is enough
  930. # indicator of success; specifically ignore xdotool failing
  931. # with BadWindow or such - when some window appears only for a
  932. # moment by xdotool didn't manage to get its properties
  933. except asyncio.TimeoutError:
  934. self.fail(
  935. "Timeout while waiting for {} window to show".format(title))
  936. return winid.decode().strip()
  937. def wait_for_window(self, *args, **kwargs):
  938. """
  939. Wait for a window with a given title. Depending on show parameter,
  940. it will wait for either window to show or to disappear.
  941. :param title: title of the window to wait for
  942. :param timeout: timeout of the operation, in seconds
  943. :param show: if True - wait for the window to be visible,
  944. otherwise - to not be visible
  945. :param search_class: search based on window class instead of title
  946. :return: window id of found window, if show=True
  947. """
  948. return self.loop.run_until_complete(
  949. self.wait_for_window_coro(*args, **kwargs))
  950. def enter_keys_in_window(self, title, keys):
  951. """
  952. Search for window with given title, then enter listed keys there.
  953. The function will wait for said window to appear.
  954. :param title: title of window
  955. :param keys: list of keys to enter, as for `xdotool key`
  956. :return: None
  957. """
  958. # 'xdotool search --sync' sometimes crashes on some race when
  959. # accessing window properties
  960. self.wait_for_window(title)
  961. command = ['xdotool', 'search', '--name', title,
  962. 'windowactivate', '--sync',
  963. 'key'] + keys
  964. subprocess.check_call(command)
  965. def shutdown_and_wait(self, vm, timeout=60):
  966. try:
  967. self.loop.run_until_complete(vm.shutdown(wait=True, timeout=timeout))
  968. except qubes.exc.QubesException:
  969. name = vm.name
  970. del vm
  971. self.fail("Timeout while waiting for VM {} shutdown".format(name))
  972. def prepare_hvm_system_linux(self, vm, init_script, extra_files=None):
  973. if not os.path.exists('/usr/lib/grub/i386-pc'):
  974. self.skipTest('grub2 not installed')
  975. if not spawn.find_executable('grub2-install'):
  976. self.skipTest('grub2-tools not installed')
  977. if not spawn.find_executable('dracut'):
  978. self.skipTest('dracut not installed')
  979. # create a single partition
  980. p = subprocess.Popen(['sfdisk', '-q', '-L', vm.storage.root_img],
  981. stdin=subprocess.PIPE,
  982. stdout=subprocess.DEVNULL,
  983. stderr=subprocess.STDOUT)
  984. p.communicate('2048,\n')
  985. assert p.returncode == 0, 'sfdisk failed'
  986. # TODO: check if root_img is really file, not already block device
  987. p = subprocess.Popen(['sudo', 'losetup', '-f', '-P', '--show',
  988. vm.storage.root_img], stdout=subprocess.PIPE)
  989. (loopdev, _) = p.communicate()
  990. loopdev = loopdev.strip()
  991. looppart = loopdev + 'p1'
  992. assert p.returncode == 0, 'losetup failed'
  993. subprocess.check_call(['sudo', 'mkfs.ext2', '-q', '-F', looppart])
  994. mountpoint = tempfile.mkdtemp()
  995. subprocess.check_call(['sudo', 'mount', looppart, mountpoint])
  996. try:
  997. subprocess.check_call(['sudo', 'grub2-install',
  998. '--target', 'i386-pc',
  999. '--modules', 'part_msdos ext2',
  1000. '--boot-directory', mountpoint, loopdev],
  1001. stderr=subprocess.DEVNULL
  1002. )
  1003. grub_cfg = '{}/grub2/grub.cfg'.format(mountpoint)
  1004. subprocess.check_call(
  1005. ['sudo', 'chown', '-R', os.getlogin(), mountpoint])
  1006. with open(grub_cfg, 'w') as f:
  1007. f.write(
  1008. "set timeout=1\n"
  1009. "menuentry 'Default' {\n"
  1010. " linux /vmlinuz root=/dev/xvda1 "
  1011. "rd.driver.blacklist=bochs_drm "
  1012. "rd.driver.blacklist=uhci_hcd console=hvc0\n"
  1013. " initrd /initrd\n"
  1014. "}"
  1015. )
  1016. p = subprocess.Popen(['uname', '-r'], stdout=subprocess.PIPE)
  1017. (kernel_version, _) = p.communicate()
  1018. kernel_version = kernel_version.strip()
  1019. kernel = '/boot/vmlinuz-{}'.format(kernel_version)
  1020. shutil.copy(kernel, os.path.join(mountpoint, 'vmlinuz'))
  1021. init_path = os.path.join(mountpoint, 'init')
  1022. with open(init_path, 'w') as f:
  1023. f.write(init_script)
  1024. os.chmod(init_path, 0o755)
  1025. dracut_args = [
  1026. '--kver', kernel_version,
  1027. '--include', init_path,
  1028. '/usr/lib/dracut/hooks/pre-pivot/initscript.sh',
  1029. '--no-hostonly', '--nolvmconf', '--nomdadmconf',
  1030. ]
  1031. if extra_files:
  1032. dracut_args += ['--install', ' '.join(extra_files)]
  1033. subprocess.check_call(
  1034. ['dracut'] + dracut_args + [os.path.join(mountpoint,
  1035. 'initrd')],
  1036. stderr=subprocess.DEVNULL
  1037. )
  1038. finally:
  1039. subprocess.check_call(['sudo', 'umount', mountpoint])
  1040. shutil.rmtree(mountpoint)
  1041. subprocess.check_call(['sudo', 'losetup', '-d', loopdev])
  1042. def create_bootable_iso(self):
  1043. '''Create simple bootable ISO image.
  1044. Type 'poweroff' to it to terminate that VM.
  1045. '''
  1046. isolinux_cfg = (
  1047. 'prompt 1\n'
  1048. 'label poweroff\n'
  1049. ' kernel poweroff.c32\n'
  1050. )
  1051. output_fd, output_path = tempfile.mkstemp('.iso')
  1052. with tempfile.TemporaryDirectory() as tmp_dir:
  1053. try:
  1054. shutil.copy('/usr/share/syslinux/isolinux.bin', tmp_dir)
  1055. shutil.copy('/usr/share/syslinux/ldlinux.c32', tmp_dir)
  1056. shutil.copy('/usr/share/syslinux/poweroff.c32', tmp_dir)
  1057. with open(os.path.join(tmp_dir, 'isolinux.cfg'), 'w') as cfg:
  1058. cfg.write(isolinux_cfg)
  1059. subprocess.check_call(['genisoimage', '-o', output_path,
  1060. '-c', 'boot.cat',
  1061. '-b', 'isolinux.bin',
  1062. '-no-emul-boot',
  1063. '-boot-load-size', '4',
  1064. '-boot-info-table',
  1065. '-q',
  1066. tmp_dir])
  1067. except FileNotFoundError:
  1068. self.skipTest('syslinux or genisoimage not installed')
  1069. os.close(output_fd)
  1070. self.addCleanup(os.unlink, output_path)
  1071. return output_path
  1072. def create_local_file(self, filename, content, mode='w'):
  1073. with open(filename, mode) as file:
  1074. file.write(content)
  1075. self.addCleanup(os.unlink, filename)
  1076. def create_remote_file(self, vm, filename, content):
  1077. self.loop.run_until_complete(vm.run_for_stdio(
  1078. 'cat > {}'.format(shlex.quote(filename)),
  1079. user='root', input=content.encode('utf-8')))
  1080. @asyncio.coroutine
  1081. def wait_for_session(self, vm):
  1082. timeout = 30
  1083. if getattr(vm, 'template', None) and 'whonix-ws' in vm.template.name:
  1084. # first boot of whonix-ws takes more time because of /home
  1085. # initialization, including Tor Browser copying
  1086. timeout = 120
  1087. yield from asyncio.wait_for(
  1088. vm.run_service_for_stdio(
  1089. 'qubes.WaitForSession', input=vm.default_user.encode()),
  1090. timeout=timeout)
  1091. _templates = None
  1092. def list_templates():
  1093. '''Returns tuple of template names available in the system.'''
  1094. global _templates
  1095. if _templates is None:
  1096. if 'QUBES_TEST_TEMPLATES' in os.environ:
  1097. _templates = os.environ['QUBES_TEST_TEMPLATES'].split()
  1098. if _templates is None:
  1099. try:
  1100. app = qubes.Qubes()
  1101. _templates = tuple(vm.name for vm in app.domains
  1102. if isinstance(vm, qubes.vm.templatevm.TemplateVM) and
  1103. vm.features.get('os', None) != 'Windows')
  1104. app.close()
  1105. del app
  1106. except OSError:
  1107. _templates = ()
  1108. return _templates
  1109. def create_testcases_for_templates(name, *bases, module, **kwds):
  1110. '''Do-it-all helper for generating per-template tests via load_tests proto
  1111. This does several things:
  1112. - creates per-template classes
  1113. - adds them to module's :py:func:`globals`
  1114. - returns an iterable suitable for passing to loader.loadTestsFromNames
  1115. TestCase classes created by this function have implicit `.template`
  1116. attribute, which contains name of the respective template. They are also
  1117. named with given prefix, underscore and template name. If template name
  1118. contains characters not valid as part of Python identifier, they are
  1119. impossible to get via standard ``.`` operator, though :py:func:`getattr` is
  1120. still usable.
  1121. >>> class MyTestsMixIn:
  1122. ... def test_000_my_test(self):
  1123. ... assert self.template.startswith('debian')
  1124. >>> def load_tests(loader, tests, pattern):
  1125. ... tests.addTests(loader.loadTestsFromNames(
  1126. ... qubes.tests.create_testcases_for_templates(
  1127. ... 'TC_00_MyTests', MyTestsMixIn, qubes.tests.SystemTestCase,
  1128. ... module=sys.modules[__name__])))
  1129. *NOTE* adding ``module=sys.modules[__name__]`` is *mandatory*, and to allow
  1130. enforcing this, it uses keyword-only argument syntax, which is only in
  1131. Python 3.
  1132. '''
  1133. # Do not attempt to grab the module from traceback, since we are actually
  1134. # a generator and loadTestsFromNames may also be a generator, so it's not
  1135. # possible to correctly guess frame from stack. Explicit is better than
  1136. # implicit!
  1137. for template in list_templates():
  1138. clsname = name + '_' + template
  1139. if hasattr(module, clsname):
  1140. continue
  1141. cls = type(clsname, bases, {'template': template, **kwds})
  1142. cls.__module__ = module.__name__
  1143. # XXX I wonder what other __dunder__ attrs did I miss
  1144. setattr(module, clsname, cls)
  1145. yield '.'.join((module.__name__, clsname))
  1146. def maybe_create_testcases_on_import(create_testcases_gen):
  1147. '''If certain conditions are met, call *create_testcases_gen* to create
  1148. testcases for templates tests. The purpose is to use it on integration
  1149. tests module(s) import, so the test runner could discover tests without
  1150. using load tests protocol.
  1151. The conditions - any of:
  1152. - QUBES_TEST_TEMPLATES present in the environment (it's possible to
  1153. create test cases without opening qubes.xml)
  1154. - QUBES_TEST_LOAD_ALL present in the environment
  1155. '''
  1156. if 'QUBES_TEST_TEMPLATES' in os.environ or \
  1157. 'QUBES_TEST_LOAD_ALL' in os.environ:
  1158. list(create_testcases_gen())
  1159. def extra_info(obj):
  1160. '''Return short info identifying object.
  1161. For example, if obj is a qube, return its name. This is for use with
  1162. :py:mod:`objgraph` package.
  1163. '''
  1164. # Feel free to extend to other cases.
  1165. if isinstance(obj, qubes.vm.qubesvm.QubesVM):
  1166. try:
  1167. return obj.name
  1168. except AttributeError:
  1169. pass
  1170. if isinstance(obj, unittest.TestCase):
  1171. return obj.id()
  1172. return ''
  1173. def load_tests(loader, tests, pattern): # pylint: disable=unused-argument
  1174. # discard any tests from this module, because it hosts base classes
  1175. tests = unittest.TestSuite()
  1176. for modname in (
  1177. # unit tests
  1178. 'qubes.tests.events',
  1179. 'qubes.tests.devices',
  1180. 'qubes.tests.devices_block',
  1181. 'qubes.tests.firewall',
  1182. 'qubes.tests.init',
  1183. 'qubes.tests.vm.init',
  1184. 'qubes.tests.storage',
  1185. 'qubes.tests.storage_file',
  1186. 'qubes.tests.storage_reflink',
  1187. 'qubes.tests.storage_lvm',
  1188. 'qubes.tests.storage_kernels',
  1189. 'qubes.tests.ext',
  1190. 'qubes.tests.vm.qubesvm',
  1191. 'qubes.tests.vm.mix.net',
  1192. 'qubes.tests.vm.adminvm',
  1193. 'qubes.tests.vm.appvm',
  1194. 'qubes.tests.vm.dispvm',
  1195. 'qubes.tests.app',
  1196. 'qubes.tests.tarwriter',
  1197. 'qubes.tests.api',
  1198. 'qubes.tests.api_admin',
  1199. 'qubes.tests.api_misc',
  1200. 'qubes.tests.api_internal',
  1201. 'qubes.tests.rpc_import',
  1202. ):
  1203. tests.addTests(loader.loadTestsFromName(modname))
  1204. tests.addTests(loader.discover(
  1205. os.path.join(os.path.dirname(__file__), 'tools')))
  1206. if not in_dom0:
  1207. return tests
  1208. for modname in (
  1209. 'qrexec.tests',
  1210. 'qrexec.tests.cli',
  1211. 'qrexec.tests.gtkhelpers',
  1212. 'qrexec.tests.rpcconfirmation',
  1213. # integration tests
  1214. 'qubes.tests.integ.basic',
  1215. 'qubes.tests.integ.storage',
  1216. 'qubes.tests.integ.grub',
  1217. 'qubes.tests.integ.devices_block',
  1218. 'qubes.tests.integ.devices_pci',
  1219. 'qubes.tests.integ.dom0_update',
  1220. 'qubes.tests.integ.network',
  1221. 'qubes.tests.integ.dispvm',
  1222. 'qubes.tests.integ.vm_qrexec_gui',
  1223. 'qubes.tests.integ.mime',
  1224. 'qubes.tests.integ.salt',
  1225. 'qubes.tests.integ.backup',
  1226. 'qubes.tests.integ.backupcompatibility',
  1227. # external modules
  1228. 'qubes.tests.extra',
  1229. ):
  1230. tests.addTests(loader.loadTestsFromName(modname))
  1231. return tests