cmdtest.py 32 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070
  1. #!/usr/bin/env python3
  2. #
  3. # mmgen = Multi-Mode GENerator, command-line Bitcoin cold storage solution
  4. # Copyright (C)2013-2024 The MMGen Project <mmgen@tuta.io>
  5. #
  6. # This program is free software: you can redistribute it and/or modify
  7. # it under the terms of the GNU General Public License as published by
  8. # the Free Software Foundation, either version 3 of the License, or
  9. # (at your option) any later version.
  10. #
  11. # This program is distributed in the hope that it will be useful,
  12. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14. # GNU General Public License for more details.
  15. #
  16. # You should have received a copy of the GNU General Public License
  17. # along with this program. If not, see <http://www.gnu.org/licenses/>.
  18. """
  19. test/cmdtest.py: Command test runner for the MMGen wallet system
  20. """
  21. def check_segwit_opts():
  22. for k,m in (('segwit','S'),('segwit_random','S'),('bech32','B')):
  23. if getattr(cfg,k) and m not in proto.mmtypes:
  24. die(1,f'--{k.replace("_","-")} option incompatible with {proto.cls_name}')
  25. def create_shm_dir(data_dir,trash_dir):
  26. # Laggy flash media can cause pexpect to fail, so create a temporary directory
  27. # under '/dev/shm' and put datadir and tmpdirs here.
  28. import shutil
  29. from subprocess import run
  30. if sys.platform == 'win32':
  31. for tdir in (data_dir,trash_dir):
  32. try:
  33. os.listdir(tdir)
  34. except:
  35. pass
  36. else:
  37. try:
  38. shutil.rmtree(tdir)
  39. except: # we couldn't remove data dir - perhaps regtest daemon is running
  40. try:
  41. run(['python3',os.path.join('cmds','mmgen-regtest'),'stop'],check=True)
  42. except:
  43. die(4,f'Unable to remove {tdir!r}!')
  44. else:
  45. time.sleep(2)
  46. shutil.rmtree(tdir)
  47. os.mkdir(tdir,0o755)
  48. shm_dir = 'test'
  49. else:
  50. tdir,pfx = '/dev/shm','mmgen-test-'
  51. try:
  52. run(f'rm -rf {tdir}/{pfx}*',shell=True,check=True)
  53. except Exception as e:
  54. die(2,f'Unable to delete directory tree {tdir}/{pfx}* ({e.args[0]})')
  55. try:
  56. import tempfile
  57. shm_dir = str(tempfile.mkdtemp('',pfx,tdir))
  58. except Exception as e:
  59. die(2,f'Unable to create temporary directory in {tdir} ({e.args[0]})')
  60. dest = os.path.join(shm_dir,os.path.basename(trash_dir))
  61. os.mkdir(dest,0o755)
  62. run(f'rm -rf {trash_dir}',shell=True,check=True)
  63. os.symlink(dest,trash_dir)
  64. dest = os.path.join(shm_dir,os.path.basename(data_dir))
  65. shutil.move(data_dir,dest) # data_dir was created by Config()
  66. os.symlink(dest,data_dir)
  67. return shm_dir
  68. import sys,os,time
  69. if sys.argv[-1] == 'clean':
  70. os.environ['MMGEN_TEST_SUITE'] = '1'
  71. repo_root = os.path.normpath(os.path.abspath(os.path.join(os.path.dirname(sys.argv[0]),os.pardir)))
  72. os.chdir(repo_root)
  73. sys.path[0] = repo_root
  74. from shutil import rmtree
  75. from test.overlay import get_overlay_tree_dir
  76. overlay_tree_dir = get_overlay_tree_dir(repo_root)
  77. rmtree(overlay_tree_dir,ignore_errors=True)
  78. print(f'Removed {os.path.relpath(overlay_tree_dir)!r}')
  79. else:
  80. # overlay must be set up before importing mmgen mods!
  81. try:
  82. from include.test_init import repo_root
  83. except ImportError:
  84. from test.include.test_init import repo_root
  85. from mmgen.cfg import Config,gc
  86. from mmgen.color import red,yellow,green,blue,cyan,gray,nocolor,init_color
  87. from mmgen.util import msg,Msg,bmsg,die,suf,make_timestr,async_run
  88. from test.include.common import (
  89. set_globals,
  90. cmdtest_py_log_fn,
  91. cmdtest_py_error_fn,
  92. mk_tmpdir,
  93. cleandir,
  94. iqmsg,
  95. omsg,
  96. omsg_r,
  97. ok,
  98. start_test_daemons,
  99. stop_test_daemons,
  100. init_coverage,
  101. )
  102. try:
  103. os.unlink(os.path.join(repo_root,cmdtest_py_error_fn))
  104. except:
  105. pass
  106. os.environ['MMGEN_QUIET'] = '0' # for this script and spawned scripts
  107. opts_data = {
  108. 'sets': [
  109. ('list_current_cmd_groups',True,'list_cmd_groups',True),
  110. ('demo',True,'exact_output',True),
  111. ('demo',True,'buf_keypress',True),
  112. ('demo',True,'pexpect_spawn',True),
  113. ],
  114. 'text': {
  115. 'desc': 'High-level tests for the MMGen Wallet suite',
  116. 'usage':'[options] [command [..command]] | [command_group[.command_subgroup][:command]]',
  117. 'options': """
  118. -h, --help Print this help message
  119. --, --longhelp Print help message for long options (common options)
  120. -a, --no-altcoin Skip altcoin tests (WIP)
  121. -A, --no-daemon-autostart Don't start and stop daemons automatically
  122. -B, --bech32 Generate and use Bech32 addresses
  123. -b, --buf-keypress Use buffered keypresses as with real human input
  124. (often required on slow systems, or under emulation)
  125. -c, --print-cmdline Print the command line of each spawned command
  126. -C, --coverage Produce code coverage info using trace module
  127. -x, --debug-pexpect Produce debugging output for pexpect calls
  128. --, --demo Add extra delay after each send to make input visible.
  129. Implies --exact-output --pexpect-spawn --buf-keypress
  130. -d, --deps-only Run a command or command subgroup’s dependencies without
  131. running the command or command group itself.
  132. -D, --no-daemon-stop Don't stop auto-started daemons after running tests
  133. -E, --direct-exec Bypass pexpect and execute a command directly (for
  134. debugging only)
  135. -e, --exact-output Show the exact output of the MMGen script(s) being run
  136. -G, --exclude-groups=G Exclude the specified command groups (comma-separated)
  137. -l, --list-cmds List the test script’s available commands
  138. -L, --list-cmd-groups List the test script’s command groups and subgroups
  139. -g, --list-current-cmd-groups List command groups for current configuration
  140. -n, --names Display command names instead of descriptions
  141. -N, --no-timings Suppress display of timing information
  142. -o, --log Log commands to file {lf!r}
  143. -O, --pexpect-spawn Use pexpect.spawn instead of popen_spawn (much slower,
  144. kut does real terminal emulation)
  145. -p, --pause Pause between tests, resuming on keypress
  146. -P, --profile Record the execution time of each script
  147. -q, --quiet Produce minimal output. Suppress dependency info
  148. -r, --resume=c Resume at command 'c' after interrupted run
  149. -R, --resume-after=c Same, but resume at command following 'c'
  150. -t, --step After resuming, execute one command and stop
  151. -S, --skip-deps Skip dependency checking for command
  152. -u, --usr-random Get random data interactively from user
  153. -T, --pexpect-timeout=T Set the timeout for pexpect
  154. -v, --verbose Produce more verbose output
  155. -W, --no-dw-delete Don't remove default wallet from data dir after dw tests
  156. are done
  157. -X, --exit-after=C Exit after command 'C'
  158. -y, --segwit Generate and use Segwit addresses
  159. -Y, --segwit-random Generate and use a random mix of Segwit and Legacy addrs
  160. """,
  161. 'notes': """
  162. If no command is given, the whole test suite is run for the currently
  163. specified coin (default BTC).
  164. For traceback output and error file support, set the EXEC_WRAPPER_TRACEBACK
  165. environment var
  166. """
  167. },
  168. 'code': {
  169. 'options': lambda proto,help_notes,s: s.format(
  170. lf = cmdtest_py_log_fn
  171. )
  172. }
  173. }
  174. # we need some opt values before running opts.init, so parse without initializing:
  175. po = Config(opts_data=opts_data,parse_only=True)._parsed_opts
  176. data_dir = Config.test_datadir
  177. # step 1: delete data_dir symlink in ./test;
  178. if not po.user_opts.get('skipping_deps'):
  179. try:
  180. os.unlink(data_dir)
  181. except:
  182. pass
  183. # step 2: opts.init will create new data_dir in ./test (if not cfg.skipping_deps)
  184. cfg = Config(opts_data=opts_data)
  185. if cfg.no_altcoin and cfg.coin != 'BTC':
  186. die(1,f'--no-altcoin incompatible with --coin={cfg.coin}')
  187. set_globals(cfg)
  188. from test.cmdtest_py_d.common import ( # this must be loaded after set_globals()
  189. get_file_with_ext,
  190. confirm_continue
  191. )
  192. type(cfg)._reset_ok += (
  193. 'no_daemon_autostart',
  194. 'names',
  195. 'no_timings',
  196. 'exit_after',
  197. 'resuming',
  198. 'skipping_deps' )
  199. logging = cfg.log or os.getenv('MMGEN_EXEC_WRAPPER')
  200. cfg.resuming = any(k in po.user_opts for k in ('resume','resume_after'))
  201. cfg.skipping_deps = cfg.resuming or 'skip_deps' in po.user_opts
  202. cmd_args = cfg._args
  203. if cfg.pexpect_spawn and sys.platform == 'win32':
  204. die(1,'--pexpect-spawn option not supported on Windows platform, exiting')
  205. if cfg.daemon_id and cfg.daemon_id in cfg.blacklisted_daemons.split():
  206. die(1,f'cmdtest.py: daemon {cfg.daemon_id!r} blacklisted, exiting')
  207. network_id = cfg.coin.lower() + ('_tn' if cfg.testnet else '')
  208. proto = cfg._proto
  209. # step 3: move data_dir to /dev/shm and symlink it back to ./test:
  210. trash_dir = os.path.join('test','trash')
  211. trash_dir2 = os.path.join('test','trash2')
  212. if not cfg.skipping_deps:
  213. shm_dir = create_shm_dir(data_dir,trash_dir)
  214. check_segwit_opts()
  215. testing_segwit = cfg.segwit or cfg.segwit_random or cfg.bech32
  216. if cfg.test_suite_deterministic:
  217. cfg.no_timings = True
  218. init_color(num_colors=0)
  219. os.environ['MMGEN_DISABLE_COLOR'] = '1' # for this script and spawned scripts
  220. if cfg.profile:
  221. cfg.names = True
  222. if cfg.exact_output:
  223. qmsg = qmsg_r = lambda s: None
  224. else:
  225. qmsg = cfg._util.qmsg
  226. qmsg_r = cfg._util.qmsg_r
  227. if cfg.skipping_deps:
  228. cfg.no_daemon_autostart = True
  229. from test.cmdtest_py_d.cfg import cfgs,fixup_cfgs
  230. for k in cfgs:
  231. cfgs[k]['tmpdir'] = os.path.join('test','tmp',str(k))
  232. fixup_cfgs()
  233. utils = {
  234. # 'check_deps': 'check dependencies for specified command (WIP)', # TODO
  235. 'clean': 'clean specified tmp dir(s) (specify by integer, no arg = all dirs)',
  236. }
  237. def list_cmds():
  238. def gen_output():
  239. gm = CmdGroupMgr()
  240. cw,d = 0,[]
  241. yield green('AVAILABLE COMMANDS:')
  242. for gname in gm.cmd_groups:
  243. tg = gm.gm_init_group(None,gname,None,None)
  244. desc = tg.__doc__.strip() if tg.__doc__ else type(tg).__name__
  245. d.append( (gname,desc,gm.cmd_list,gm.dpy_data) )
  246. cw = max(max(len(k) for k in gm.dpy_data),cw)
  247. for gname,gdesc,clist,dpdata in d:
  248. yield '\n'+green(f'{gname!r} - {gdesc}:')
  249. for cmd in clist:
  250. data = dpdata[cmd]
  251. yield ' {:{w}} - {}'.format(
  252. cmd,
  253. (data if isinstance(data,str) else data[1]),
  254. w = cw )
  255. w = max(map(len,utils))
  256. yield '\n'+green('AVAILABLE UTILITIES:')
  257. for cmd in sorted(utils):
  258. yield f' {cmd:{w}} - {utils[cmd]}'
  259. from mmgen.ui import do_pager
  260. do_pager('\n'.join(gen_output()))
  261. sys.exit(0)
  262. def do_between():
  263. if cfg.pause:
  264. confirm_continue()
  265. elif (cfg.verbose or cfg.exact_output) and not cfg.skipping_deps:
  266. sys.stderr.write('\n')
  267. def list_tmpdirs():
  268. return {k:cfgs[k]['tmpdir'] for k in cfgs}
  269. def clean(usr_dirs=None,clean_overlay=True):
  270. if cfg.skipping_deps:
  271. return
  272. all_dirs = list_tmpdirs()
  273. dirnums = map(int,(usr_dirs if usr_dirs is not None else all_dirs))
  274. dirlist = list(map(str,sorted(dirnums)))
  275. for d in dirlist:
  276. if d in all_dirs:
  277. cleandir(all_dirs[d])
  278. else:
  279. die(1,f'{d}: invalid directory number')
  280. if dirlist:
  281. iqmsg(green('Cleaned tmp director{} {}'.format(
  282. suf(dirlist,'ies'),
  283. ' '.join(dirlist))
  284. ))
  285. cleandir(data_dir)
  286. cleandir(trash_dir)
  287. cleandir(trash_dir2)
  288. iqmsg(green(f'Cleaned directories {data_dir!r} {trash_dir!r} {trash_dir2!r}'))
  289. if clean_overlay:
  290. cleandir(overlay_tree_dir)
  291. iqmsg(green(f'Cleaned directory {os.path.relpath(overlay_tree_dir)!r}'))
  292. def create_tmp_dirs(shm_dir):
  293. if sys.platform == 'win32':
  294. for cfg in sorted(cfgs):
  295. mk_tmpdir(cfgs[cfg]['tmpdir'])
  296. else:
  297. os.makedirs( os.path.join('test','tmp'), mode=0o755, exist_ok=True )
  298. for cfg in sorted(cfgs):
  299. src = os.path.join(shm_dir,cfgs[cfg]['tmpdir'].split('/')[-1])
  300. mk_tmpdir(src)
  301. try:
  302. os.unlink(cfgs[cfg]['tmpdir'])
  303. except OSError as e:
  304. if e.errno != 2:
  305. raise
  306. finally:
  307. os.symlink(src,cfgs[cfg]['tmpdir'])
  308. def set_restore_term_at_exit():
  309. import termios,atexit
  310. fd = sys.stdin.fileno()
  311. old = termios.tcgetattr(fd)
  312. def at_exit():
  313. termios.tcsetattr(fd, termios.TCSADRAIN, old)
  314. atexit.register(at_exit)
  315. class CmdGroupMgr:
  316. dpy_data = None
  317. from test.cmdtest_py_d.cfg import cmd_groups_dfl,cmd_groups_extra
  318. cmd_groups = cmd_groups_dfl.copy()
  319. cmd_groups.update(cmd_groups_extra)
  320. @staticmethod
  321. def create_cmd_group(cls,sg_name=None):
  322. cmd_group_in = dict(cls.cmd_group_in)
  323. if sg_name and 'subgroup.' + sg_name not in cmd_group_in:
  324. die(1,f'{sg_name!r}: no such subgroup in test group {cls.__name__}')
  325. def add_entries(key,add_deps=True,added_subgroups=[]):
  326. if add_deps:
  327. for dep in cmd_group_in['subgroup.'+key]:
  328. for e in add_entries(dep):
  329. yield e
  330. assert isinstance(cls.cmd_subgroups[key][0],str), f'header for subgroup {key!r} missing!'
  331. if not key in added_subgroups:
  332. for e in cls.cmd_subgroups[key][1:]:
  333. yield e
  334. added_subgroups.append(key)
  335. def gen():
  336. for name,data in cls.cmd_group_in:
  337. if name.startswith('subgroup.'):
  338. sg_key = name.removeprefix('subgroup.')
  339. if sg_name in (None,sg_key):
  340. for e in add_entries(
  341. sg_key,
  342. add_deps = sg_name and not cfg.skipping_deps,
  343. added_subgroups = [sg_name] if cfg.deps_only else [] ):
  344. yield e
  345. if cfg.deps_only and sg_key == sg_name:
  346. return
  347. elif not cfg.skipping_deps:
  348. yield (name,data)
  349. return tuple(gen())
  350. def load_mod(self,gname,modname=None):
  351. clsname,kwargs = self.cmd_groups[gname]
  352. if modname is None and 'modname' in kwargs:
  353. modname = kwargs['modname']
  354. import importlib
  355. modpath = f'test.cmdtest_py_d.ct_{modname or gname}'
  356. return getattr(importlib.import_module(modpath),clsname)
  357. def create_group(self,gname,sg_name,full_data=False,modname=None,is3seed=False,add_dpy=False):
  358. """
  359. Initializes the list 'cmd_list' and dict 'dpy_data' from module's cmd_group data.
  360. Alternatively, if called with 'add_dpy=True', updates 'dpy_data' from module data
  361. without touching 'cmd_list'
  362. """
  363. cls = self.load_mod(gname,modname)
  364. cdata = []
  365. def get_shared_deps(cmdname,tmpdir_idx):
  366. """
  367. shared_deps are "implied" dependencies for all cmds in cmd_group that don't appear in
  368. the cmd_group data or cmds' argument lists. Supported only for 3seed tests at present.
  369. """
  370. if not hasattr(cls,'shared_deps'):
  371. return []
  372. return [k for k,v in cfgs[str(tmpdir_idx)]['dep_generators'].items()
  373. if k in cls.shared_deps and v != cmdname]
  374. if not hasattr(cls,'cmd_group'):
  375. cls.cmd_group = self.create_cmd_group(cls,sg_name)
  376. for a,b in cls.cmd_group:
  377. if is3seed:
  378. for n,(i,j) in enumerate(zip(cls.tmpdir_nums,(128,192,256))):
  379. k = f'{a}_{n+1}'
  380. if hasattr(cls,'skip_cmds') and k in cls.skip_cmds:
  381. continue
  382. sdeps = get_shared_deps(k,i)
  383. if isinstance(b,str):
  384. cdata.append( (k, (i,f'{b} ({j}-bit)',[[[]+sdeps,i]])) )
  385. else:
  386. cdata.append( (k, (i,f'{b[1]} ({j}-bit)',[[b[0]+sdeps,i]])) )
  387. else:
  388. cdata.append( (a, b if full_data else (cls.tmpdir_nums[0],b,[[[],cls.tmpdir_nums[0]]])) )
  389. if add_dpy:
  390. self.dpy_data.update(dict(cdata))
  391. else:
  392. self.cmd_list = tuple(e[0] for e in cdata)
  393. self.dpy_data = dict(cdata)
  394. return cls
  395. def gm_init_group(self,trunner,gname,sg_name,spawn_prog):
  396. kwargs = self.cmd_groups[gname][1]
  397. cls = self.create_group(gname,sg_name,**kwargs)
  398. cls.group_name = gname
  399. return cls(trunner,cfgs,spawn_prog)
  400. def get_cls_by_gname(self,gname):
  401. return self.load_mod( gname, self.cmd_groups[gname][1].get('modname') )
  402. def list_cmd_groups(self):
  403. ginfo = []
  404. for gname in self.cmd_groups:
  405. ginfo.append(( gname, self.get_cls_by_gname(gname) ))
  406. if cfg.list_current_cmd_groups:
  407. exclude = (cfg.exclude_groups or '').split(',')
  408. ginfo = [g for g in ginfo
  409. if network_id in g[1].networks
  410. and not g[0] in exclude
  411. and g[0] in tuple(self.cmd_groups_dfl) + tuple(cmd_args) ]
  412. desc = 'CONFIGURED'
  413. else:
  414. desc = 'AVAILABLE'
  415. def gen_output():
  416. yield green(f'{desc} COMMAND GROUPS AND SUBGROUPS:')
  417. yield ''
  418. for name,cls in ginfo:
  419. yield ' {} - {}'.format(
  420. yellow(name.ljust(13)),
  421. (cls.__doc__.strip() if cls.__doc__ else cls.__name__) )
  422. if hasattr(cls,'cmd_subgroups'):
  423. subgroups = {k:v for k,v in cls.cmd_subgroups.items() if not k.startswith('_')}
  424. max_w = max(len(k) for k in subgroups)
  425. for k,v in subgroups.items():
  426. yield ' + {} · {}'.format( cyan(k.ljust(max_w+1)), v[0] )
  427. from mmgen.ui import do_pager
  428. do_pager('\n'.join(gen_output()))
  429. Msg( '\n' + ' '.join(e[0] for e in ginfo) )
  430. sys.exit(0)
  431. def find_cmd_in_groups(self,cmd,group=None):
  432. """
  433. Search for a test command in specified group or all configured command groups
  434. and return it as a string. Loads modules but alters no global variables.
  435. """
  436. if group:
  437. if not group in [e[0] for e in self.cmd_groups]:
  438. die(1,f'{group!r}: unrecognized group')
  439. groups = [self.cmd_groups[group]]
  440. else:
  441. groups = self.cmd_groups
  442. for gname in groups:
  443. cls = self.get_cls_by_gname(gname)
  444. if not hasattr(cls,'cmd_group'):
  445. cls.cmd_group = self.create_cmd_group(cls)
  446. if cmd in cls.cmd_group: # first search the class
  447. return gname
  448. if cmd in dir(cls(None,None,None)): # then a throwaway instance
  449. return gname # cmd might exist in more than one group - we'll go with the first
  450. return None
  451. class CmdTestRunner:
  452. 'cmdtest.py test runner'
  453. def __del__(self):
  454. if logging:
  455. self.log_fd.close()
  456. def __init__(self,data_dir,trash_dir):
  457. self.data_dir = data_dir
  458. self.trash_dir = trash_dir
  459. self.cmd_total = 0
  460. self.rebuild_list = {}
  461. self.gm = CmdGroupMgr()
  462. self.repo_root = repo_root
  463. self.skipped_warnings = []
  464. self.resume_cmd = None
  465. self.deps_only = None
  466. if logging:
  467. self.log_fd = open(cmdtest_py_log_fn,'a')
  468. self.log_fd.write(f'\nLog started: {make_timestr()} UTC\n')
  469. omsg(f'INFO → Logging to file {cmdtest_py_log_fn!r}')
  470. else:
  471. self.log_fd = None
  472. if cfg.coverage:
  473. coverdir,accfile = init_coverage()
  474. omsg(f'INFO → Writing coverage files to {coverdir!r}')
  475. self.pre_args = ['python3','-m','trace','--count','--coverdir='+coverdir,'--file='+accfile]
  476. else:
  477. self.pre_args = ['python3'] if sys.platform == 'win32' else []
  478. if cfg.pexpect_spawn:
  479. omsg('INFO → Using pexpect.spawn() for real terminal emulation')
  480. self.set_spawn_env()
  481. def set_spawn_env(self):
  482. self.spawn_env = dict(os.environ)
  483. self.spawn_env.update({
  484. 'MMGEN_NO_LICENSE': '1',
  485. 'MMGEN_BOGUS_SEND': '1',
  486. 'MMGEN_TEST_SUITE_PEXPECT': '1',
  487. 'EXEC_WRAPPER_SPAWN':'1',
  488. # if cmdtest.py itself is running under exec_wrapper, disable writing of traceback file for spawned script
  489. 'EXEC_WRAPPER_TRACEBACK': '' if os.getenv('MMGEN_EXEC_WRAPPER') else '1',
  490. })
  491. if cfg.exact_output:
  492. from mmgen.term import get_terminal_size
  493. self.spawn_env['MMGEN_COLUMNS'] = str(get_terminal_size().width)
  494. else:
  495. self.spawn_env['MMGEN_COLUMNS'] = '120'
  496. def spawn_wrapper(
  497. self,
  498. cmd,
  499. args = [],
  500. extra_desc = '',
  501. no_output = False,
  502. msg_only = False,
  503. no_msg = False,
  504. cmd_dir = 'cmds',
  505. no_exec_wrapper = False,
  506. timeout = None,
  507. pexpect_spawn = None,
  508. direct_exec = False,
  509. env = {}):
  510. desc = self.tg.test_name if cfg.names else self.gm.dpy_data[self.tg.test_name][1]
  511. if extra_desc:
  512. desc += ' ' + extra_desc
  513. cmd_path = (
  514. cmd if cfg.system # cfg.system is broken for main test group with overlay tree
  515. else os.path.relpath(os.path.join(repo_root,cmd_dir,cmd)) )
  516. args = (
  517. self.pre_args +
  518. ([] if no_exec_wrapper else ['scripts/exec_wrapper.py']) +
  519. [cmd_path] +
  520. self.passthru_opts +
  521. self.tg.extra_spawn_args +
  522. args )
  523. try:
  524. qargs = ['{q}{}{q}'.format( a, q = "'" if ' ' in a else '' ) for a in args]
  525. except:
  526. msg(f'args: {args}')
  527. raise
  528. cmd_disp = ' '.join(qargs).replace('\\','/') # for mingw
  529. if logging:
  530. self.log_fd.write('[{}][{}:{}] {}\n'.format(
  531. proto.coin.lower(),
  532. self.tg.group_name,
  533. self.tg.test_name,
  534. cmd_disp))
  535. for i in args: # die only after writing log entry
  536. if not isinstance(i,str):
  537. die(2,'Error: missing input files in cmd line?:\nName: {}\nCmdline: {!r}'.format(
  538. self.tg.test_name,
  539. args ))
  540. if not no_msg:
  541. t_pfx = '' if cfg.no_timings else f'[{time.time() - self.start_time:08.2f}] '
  542. if cfg.verbose or cfg.print_cmdline or cfg.exact_output:
  543. omsg(green(f'{t_pfx}Testing: {desc}'))
  544. if not msg_only:
  545. clr1,clr2 = (nocolor,nocolor) if cfg.print_cmdline else (green,cyan)
  546. omsg(
  547. clr1('Executing: ') +
  548. clr2(repr(cmd_disp) if sys.platform == 'win32' else cmd_disp)
  549. )
  550. else:
  551. omsg_r('{a}Testing {b}: {c}'.format(
  552. a = t_pfx,
  553. b = desc,
  554. c = 'OK\n' if direct_exec or cfg.direct_exec else ''))
  555. if msg_only:
  556. return
  557. # NB: the `pexpect_spawn` arg enables hold_protect and send_delay while the corresponding cmdline
  558. # option does not. For performance reasons, this is the desired behavior. For full emulation of
  559. # the user experience with hold protect enabled, specify --buf-keypress or --demo.
  560. send_delay = 0.4 if pexpect_spawn is True or cfg.buf_keypress else None
  561. pexpect_spawn = pexpect_spawn if pexpect_spawn is not None else bool(cfg.pexpect_spawn)
  562. spawn_env = dict(self.tg.spawn_env)
  563. spawn_env.update({
  564. 'MMGEN_HOLD_PROTECT_DISABLE': '' if send_delay else '1',
  565. 'MMGEN_TEST_SUITE_POPEN_SPAWN': '' if pexpect_spawn else '1',
  566. })
  567. spawn_env.update(env)
  568. from test.include.pexpect import MMGenPexpect
  569. return MMGenPexpect(
  570. args = args,
  571. no_output = no_output,
  572. spawn_env = spawn_env,
  573. pexpect_spawn = pexpect_spawn,
  574. timeout = timeout,
  575. send_delay = send_delay,
  576. direct_exec = direct_exec )
  577. def end_msg(self):
  578. t = int(time.time() - self.start_time)
  579. sys.stderr.write(green(
  580. f'{self.cmd_total} test{suf(self.cmd_total)} performed' +
  581. ('\n' if cfg.no_timings else f'. Elapsed time: {t//60:02d}:{t%60:02d}\n')
  582. ))
  583. def init_group(self,gname,sg_name=None,cmd=None,quiet=False,do_clean=True):
  584. from test.cmdtest_py_d.cfg import cmd_groups_altcoin
  585. if cfg.no_altcoin and gname in cmd_groups_altcoin:
  586. omsg(gray(f'INFO → skipping test group {gname!r} (--no-altcoin)'))
  587. return None
  588. ct_cls = CmdGroupMgr().load_mod(gname)
  589. if sys.platform == 'win32' and ct_cls.win_skip:
  590. omsg(gray(f'INFO → skipping test {gname!r} (platform=win32)'))
  591. return False
  592. for k in ('segwit','segwit_random','bech32'):
  593. if getattr(cfg,k):
  594. segwit_opt = k
  595. break
  596. else:
  597. segwit_opt = None
  598. def gen_msg():
  599. yield ('{g}:{c}' if cmd else 'test group {g!r}').format(g=gname,c=cmd)
  600. if len(ct_cls.networks) != 1:
  601. yield f' for {proto.coin} {proto.network}'
  602. if segwit_opt:
  603. yield ' (--{})'.format( segwit_opt.replace('_','-') )
  604. m = ''.join(gen_msg())
  605. if segwit_opt and not ct_cls.segwit_opts_ok:
  606. iqmsg(gray(f'INFO → skipping {m}'))
  607. return False
  608. # 'networks = ()' means all networks allowed
  609. nws = [(e.split('_')[0],'testnet') if '_' in e else (e,'mainnet') for e in ct_cls.networks]
  610. if nws:
  611. coin = proto.coin.lower()
  612. nw = ('mainnet','testnet')[proto.testnet]
  613. for a,b in nws:
  614. if a == coin and b == nw:
  615. break
  616. else:
  617. iqmsg(gray(f'INFO → skipping {m} (network={nw})'))
  618. return False
  619. if do_clean:
  620. clean(ct_cls.tmpdir_nums,clean_overlay=False)
  621. if not quiet:
  622. bmsg('Executing ' + m)
  623. if (not self.daemon_started) and self.gm.get_cls_by_gname(gname).need_daemon:
  624. start_test_daemons(network_id,remove_datadir=True)
  625. self.daemon_started = True
  626. self.tg = self.gm.gm_init_group(self,gname,sg_name,self.spawn_wrapper)
  627. self.ct_clsname = type(self.tg).__name__
  628. # pass through opts from cmdline (po.user_opts)
  629. self.passthru_opts = ['--{}{}'.format(
  630. k.replace('_','-'),
  631. '' if cfg._uopts[k] is True else '=' + cfg._uopts[k]
  632. ) for k in cfg._uopts if k in self.tg.base_passthru_opts + self.tg.passthru_opts]
  633. if cfg.resuming:
  634. rc = cfg.resume or cfg.resume_after
  635. offset = 1 if cfg.resume_after else 0
  636. self.resume_cmd = self.gm.cmd_list[self.gm.cmd_list.index(rc)+offset]
  637. omsg(f'INFO → Resuming at command {self.resume_cmd!r}')
  638. if cfg.step:
  639. cfg.exit_after = self.resume_cmd
  640. if cfg.exit_after and cfg.exit_after not in self.gm.cmd_list:
  641. die(1,f'{cfg.exit_after!r}: command not recognized')
  642. return True
  643. def run_tests(self,cmd_args):
  644. self.start_time = time.time()
  645. self.daemon_started = False
  646. gname_save = None
  647. if cmd_args:
  648. for arg in cmd_args:
  649. if arg in self.gm.cmd_groups:
  650. if not self.init_group(arg):
  651. continue
  652. for cmd in self.gm.cmd_list:
  653. self.check_needs_rerun(cmd,build=True)
  654. do_between()
  655. else:
  656. def parse_arg(arg):
  657. if '.' in arg:
  658. a,b = arg.split('.')
  659. return [a] + b.split(':') if ':' in b else [a,b,None]
  660. elif ':' in arg:
  661. a,b = arg.split(':')
  662. return [a,None,b]
  663. else:
  664. return [self.gm.find_cmd_in_groups(arg),None,arg]
  665. gname,sg_name,cmdname = parse_arg(arg)
  666. if gname:
  667. same_grp = gname == gname_save # same group as previous cmd: don't clean, suppress blue msg
  668. if not self.init_group(gname,sg_name,cmdname,quiet=same_grp,do_clean=not same_grp):
  669. continue
  670. if cmdname:
  671. if cfg.deps_only:
  672. self.deps_only = cmdname
  673. try:
  674. self.check_needs_rerun(cmdname,build=True)
  675. except Exception as e: # allow calling of functions not in cmd_group
  676. if isinstance(e,KeyError) and e.args[0] == cmdname:
  677. ret = getattr(self.tg,cmdname)()
  678. if type(ret).__name__ == 'coroutine':
  679. async_run(ret)
  680. else:
  681. raise
  682. do_between()
  683. else:
  684. for cmd in self.gm.cmd_list:
  685. self.check_needs_rerun(cmd,build=True)
  686. do_between()
  687. gname_save = gname
  688. else:
  689. die(1,f'{arg!r}: command not recognized')
  690. else:
  691. if cfg.exclude_groups:
  692. exclude = cfg.exclude_groups.split(',')
  693. for e in exclude:
  694. if e not in self.gm.cmd_groups_dfl:
  695. die(1,f'{e!r}: group not recognized')
  696. for gname in self.gm.cmd_groups_dfl:
  697. if cfg.exclude_groups and gname in exclude:
  698. continue
  699. if not self.init_group(gname):
  700. continue
  701. for cmd in self.gm.cmd_list:
  702. self.check_needs_rerun(cmd,build=True)
  703. do_between()
  704. self.end_msg()
  705. def check_needs_rerun(
  706. self,
  707. cmd,
  708. build = False,
  709. root = True,
  710. force_delete = False,
  711. dpy = False):
  712. self.tg.test_name = cmd
  713. if self.ct_clsname == 'CmdTestMain' and testing_segwit and cmd not in self.tg.segwit_do:
  714. return False
  715. rerun = root # force_delete is not passed to recursive call
  716. fns = []
  717. if force_delete or not root:
  718. # does cmd produce a needed dependency(ies)?
  719. ret = self.get_num_exts_for_cmd(cmd)
  720. if ret:
  721. for ext in ret[1]:
  722. fn = get_file_with_ext(cfgs[ret[0]]['tmpdir'],ext,delete=build)
  723. if fn:
  724. if force_delete:
  725. os.unlink(fn)
  726. else: fns.append(fn)
  727. else: rerun = True
  728. fdeps = self.generate_file_deps(cmd)
  729. cdeps = self.generate_cmd_deps(fdeps)
  730. for fn in fns:
  731. my_age = os.stat(fn).st_mtime
  732. for num,ext in fdeps:
  733. f = get_file_with_ext(cfgs[num]['tmpdir'],ext,delete=build)
  734. if f and os.stat(f).st_mtime > my_age:
  735. rerun = True
  736. for cdep in cdeps:
  737. if self.check_needs_rerun(cdep,build=build,root=False,dpy=cmd):
  738. rerun = True
  739. if build:
  740. if rerun:
  741. for fn in fns:
  742. if not root:
  743. os.unlink(fn)
  744. if not (dpy and cfg.skipping_deps):
  745. self.run_test(cmd)
  746. if not root:
  747. do_between()
  748. else:
  749. # If prog produces multiple files:
  750. if cmd not in self.rebuild_list or rerun is True:
  751. self.rebuild_list[cmd] = (rerun,fns[0] if fns else '') # FIX
  752. return rerun
  753. def run_test(self,cmd):
  754. if self.deps_only and cmd == self.deps_only:
  755. sys.exit(0)
  756. d = [(str(num),ext) for exts,num in self.gm.dpy_data[cmd][2] for ext in exts]
  757. # delete files depended on by this cmd
  758. arg_list = [get_file_with_ext(cfgs[num]['tmpdir'],ext) for num,ext in d]
  759. # remove shared_deps from arg list
  760. if hasattr(self.tg,'shared_deps'):
  761. arg_list = arg_list[:-len(self.tg.shared_deps)]
  762. if self.resume_cmd:
  763. if cmd != self.resume_cmd:
  764. return
  765. bmsg(f'Resuming at {self.resume_cmd!r}')
  766. self.resume_cmd = None
  767. cfg.skipping_deps = False
  768. cfg.resuming = False
  769. if cfg.profile:
  770. start = time.time()
  771. self.tg.test_name = cmd # NB: Do not remove, this needs to be set twice
  772. cdata = self.gm.dpy_data[cmd]
  773. # self.tg.test_dpydata = cdata
  774. self.tg.tmpdir_num = cdata[0]
  775. # self.tg.cfg = cfgs[str(cdata[0])] # will remove this eventually
  776. test_cfg = cfgs[str(cdata[0])]
  777. for k in ( 'seed_len', 'seed_id',
  778. 'wpasswd', 'kapasswd',
  779. 'segwit', 'hash_preset',
  780. 'bw_filename', 'bw_params', 'ref_bw_seed_id',
  781. 'addr_idx_list', 'pass_idx_list' ):
  782. if k in test_cfg:
  783. setattr(self.tg,k,test_cfg[k])
  784. ret = getattr(self.tg,cmd)(*arg_list) # run the test
  785. if type(ret).__name__ == 'coroutine':
  786. ret = async_run(ret)
  787. self.process_retval(cmd,ret)
  788. if cfg.profile:
  789. omsg('\r\033[50C{:.4f}'.format( time.time() - start ))
  790. if cmd == cfg.exit_after:
  791. sys.exit(0)
  792. def warn_skipped(self):
  793. if self.skipped_warnings:
  794. print(yellow('The following tests were skipped and may require attention:'))
  795. r = '-' * 72 + '\n'
  796. print(r+('\n'+r).join(self.skipped_warnings))
  797. def process_retval(self,cmd,ret):
  798. if type(ret).__name__ == 'MMGenPexpect':
  799. ret.ok()
  800. self.cmd_total += 1
  801. elif ret == 'ok':
  802. ok()
  803. self.cmd_total += 1
  804. elif ret == 'error':
  805. die(2,red(f'\nTest {self.tg.test_name!r} failed'))
  806. elif ret in ('skip','silent'):
  807. if ret == 'silent':
  808. self.cmd_total += 1
  809. elif isinstance(ret,tuple) and ret[0] == 'skip_warn':
  810. self.skipped_warnings.append(
  811. 'Test {!r} was skipped:\n {}'.format(cmd,'\n '.join(ret[1].split('\n'))))
  812. else:
  813. die(2,f'{cmd!r} returned {ret}')
  814. def check_deps(self,cmds): # TODO: broken
  815. if len(cmds) != 1:
  816. die(1,f'Usage: {gc.prog_name} check_deps <command>')
  817. cmd = cmds[0]
  818. if cmd not in self.gm.cmd_list:
  819. die(1,f'{cmd!r}: unrecognized command')
  820. if not cfg.quiet:
  821. omsg(f'Checking dependencies for {cmd!r}')
  822. self.check_needs_rerun(self.tg,cmd)
  823. w = max(map(len,self.rebuild_list)) + 1
  824. for cmd in self.rebuild_list:
  825. c = self.rebuild_list[cmd]
  826. m = 'Rebuild' if (c[0] and c[1]) else 'Build' if c[0] else 'OK'
  827. omsg('cmd {:<{w}} {}'.format( cmd+':', m, w=w ))
  828. def generate_file_deps(self,cmd):
  829. return [(str(n),e) for exts,n in self.gm.dpy_data[cmd][2] for e in exts]
  830. def generate_cmd_deps(self,fdeps):
  831. return [cfgs[str(n)]['dep_generators'][ext] for n,ext in fdeps]
  832. def get_num_exts_for_cmd(self,cmd):
  833. try:
  834. num = str(self.gm.dpy_data[cmd][0])
  835. except KeyError:
  836. qmsg_r(f'Missing dependency {cmd!r}')
  837. gname = self.gm.find_cmd_in_groups(cmd)
  838. if gname:
  839. kwargs = self.gm.cmd_groups[gname][1]
  840. kwargs.update({'add_dpy':True})
  841. self.gm.create_group(gname,None,**kwargs)
  842. num = str(self.gm.dpy_data[cmd][0])
  843. qmsg(f' found in group {gname!r}')
  844. else:
  845. qmsg(' not found in any command group!')
  846. raise
  847. dgl = cfgs[num]['dep_generators']
  848. if cmd in dgl.values():
  849. exts = [k for k in dgl if dgl[k] == cmd]
  850. return (num,exts)
  851. else:
  852. return None
  853. if __name__ == '__main__':
  854. if not cfg.skipping_deps: # do this before list cmds exit, so we stay in sync with shm_dir
  855. create_tmp_dirs(shm_dir)
  856. if cfg.list_cmd_groups:
  857. CmdGroupMgr().list_cmd_groups()
  858. elif cfg.list_cmds:
  859. list_cmds()
  860. elif cmd_args and cmd_args[0] in utils:
  861. globals()[cmd_args[0]](*cmd_args[1:])
  862. sys.exit(0)
  863. if cfg.pause:
  864. set_restore_term_at_exit()
  865. from mmgen.exception import TestSuiteException,TestSuiteFatalException,TestSuiteSpawnedScriptException
  866. try:
  867. tr = CmdTestRunner(data_dir,trash_dir)
  868. tr.run_tests(cmd_args)
  869. tr.warn_skipped()
  870. if tr.daemon_started:
  871. stop_test_daemons(network_id)
  872. except KeyboardInterrupt:
  873. if tr.daemon_started:
  874. stop_test_daemons(network_id)
  875. tr.warn_skipped()
  876. die(1,'\ntest.py exiting at user request')
  877. except TestSuiteException as e:
  878. die(2,e.args[0])
  879. except TestSuiteFatalException as e:
  880. die(4,e.args[0])
  881. except TestSuiteSpawnedScriptException as e:
  882. # if spawned script is not running under exec_wrapper, output brief error msg:
  883. if os.getenv('MMGEN_EXEC_WRAPPER'):
  884. Msg(red(str(e)))
  885. Msg(blue('cmdtest.py: spawned script exited with error'))
  886. except Exception:
  887. # if cmdtest.py itself is running under exec_wrapper, re-raise so exec_wrapper can handle exception:
  888. if os.getenv('MMGEN_EXEC_WRAPPER') or not os.getenv('MMGEN_IGNORE_TEST_PY_EXCEPTION'):
  889. raise
  890. die(1,red('Test script exited with error'))