tooltest.py 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343
  1. #!/usr/bin/python
  2. # Chdir to repo root.
  3. # Since script is not in repo root, fix sys.path so that modules are
  4. # imported from repo, not system.
  5. import sys,os
  6. pn = os.path.dirname(sys.argv[0])
  7. os.chdir(os.path.join(pn,os.pardir))
  8. sys.path.__setitem__(0,os.path.abspath(os.curdir))
  9. import mmgen.opt as opt
  10. from mmgen.util import msg,msg_r,vmsg,vmsg_r,Msg,msgrepr, msgrepr_exit
  11. from collections import OrderedDict
  12. cmd_data = OrderedDict([
  13. ('util', {
  14. 'desc': "base conversion, hashing and file utilities",
  15. 'cmd_data': OrderedDict([
  16. ('strtob58', ()),
  17. ('b58tostr', ("strtob58","io")),
  18. ('hextob58', ()),
  19. ('b58tohex', ("hextob58","io")),
  20. ('b58randenc', ()),
  21. ('hextob32', ()),
  22. ('b32tohex', ("hextob32","io")),
  23. ('randhex', ()),
  24. ('id8', ()),
  25. ('id6', ()),
  26. ('str2id6', ()),
  27. ("sha256x2", ()),
  28. ("hexreverse", ()),
  29. ("hexlify", ()),
  30. ('hexdump', ()),
  31. ('unhexdump', ("hexdump","io")),
  32. ('rand2file', ()),
  33. ])
  34. }
  35. ),
  36. ('bitcoin', {
  37. 'desc': "Bitcoin address/key commands",
  38. 'cmd_data': OrderedDict([
  39. ('randwif', ()),
  40. ('randpair', ()),
  41. ('wif2addr', ("randpair","o2")),
  42. ('wif2hex', ("randpair","o2")),
  43. ('privhex2addr', ("wif2hex","o2")), # wif from randpair o2
  44. ('hex2wif', ("wif2hex","io2")),
  45. ('addr2hexaddr', ("randpair","o2")),
  46. ('hexaddr2addr', ("addr2hexaddr","io2")),
  47. # ("pubkey2addr", ['<public key in hex format> [str]']),
  48. # ("pubkey2hexaddr", ['<public key in hex format> [str]']),
  49. ])
  50. }
  51. ),
  52. ('mnemonic', {
  53. 'desc': "mnemonic commands",
  54. 'cmd_data': OrderedDict([
  55. ('hex2mn', ()),
  56. ('mn2hex', ("hex2mn","io3")),
  57. ('mn_rand128', ()),
  58. ('mn_rand192', ()),
  59. ('mn_rand256', ()),
  60. ('mn_stats', ()),
  61. ('mn_printlist', ()),
  62. ])
  63. }
  64. )
  65. ])
  66. cfg = {
  67. 'name': "the tool utility",
  68. 'enc_passwd': "Ten Satoshis",
  69. 'tmpdir': "test/tmp10",
  70. 'tmpdir_num': 10,
  71. }
  72. opts_data = {
  73. 'desc': "Test suite for the 'mmgen-tool' utility",
  74. 'usage':"[options] [command]",
  75. 'options': """
  76. -h, --help Print this help message
  77. -l, --list-cmds List and describe the tests and commands in the test suite
  78. -s, --system Test scripts and modules installed on system rather than
  79. those in the repo root
  80. -v, --verbose Produce more verbose output
  81. """,
  82. 'notes': """
  83. If no command is given, the whole suite of tests is run.
  84. """
  85. }
  86. cmd_args = opt.opts.init(opts_data,add_opts=["exact_output"])
  87. if opt.system: sys.path.pop(0)
  88. if opt.debug: opt.verbose = True
  89. if opt.list_cmds:
  90. fs = " {:<{w}} - {}"
  91. Msg("Available commands:")
  92. w = max([len(i) for i in cmd_data])
  93. for cmd in cmd_data:
  94. Msg(fs.format(cmd,cmd_data[cmd]['desc'],w=w))
  95. Msg("\nAvailable utilities:")
  96. Msg(fs.format("clean","Clean the tmp directory",w=w))
  97. sys.exit()
  98. import binascii
  99. from mmgen.test import *
  100. from mmgen.util import get_data_from_file,write_to_file,get_lines_from_file
  101. from mmgen.tx import is_wif,is_btc_addr,is_b58_str
  102. from mmgen.mnemonic import get_seed_from_mnemonic
  103. class MMGenToolTestSuite(object):
  104. def __init__(self):
  105. pass
  106. def gen_deps_for_cmd(self,cmd,cdata):
  107. fns = []
  108. if cdata:
  109. name,code = cdata
  110. io,count = code,1
  111. if code[-1] in "0123456789":
  112. io,count = code[:-1],int(code[-1])
  113. for c in range(count):
  114. fns += ["%s%s%s" % (
  115. name,
  116. (c+1 if count > 1 else ""),
  117. ('.in' if ch=='i' else '.out')
  118. ) for ch in io]
  119. return fns
  120. def get_num_exts_for_cmd(self,cmd,dpy): # dpy required here
  121. num = str(tool_cfgs['tmpdir_num'])
  122. # return only first file - a hack
  123. exts = gen_deps_for_cmd(dpy)
  124. return num,exts
  125. def do_cmds(self,cmd_group):
  126. cdata = cmd_data[cmd_group]['cmd_data']
  127. for cmd in cdata: self.do_cmd(cmd,cdata[cmd])
  128. def do_cmd(self,cmd,cdata):
  129. fns = self.gen_deps_for_cmd(cmd,cdata)
  130. file_list = [os.path.join(cfg['tmpdir'],fn) for fn in fns]
  131. self.__class__.__dict__[cmd](*([self,cmd] + file_list))
  132. def run_cmd(self,name,tool_args,kwargs="",extra_msg="",silent=False):
  133. mmgen_tool = "mmgen-tool"
  134. if not opt.system:
  135. mmgen_tool = os.path.join(os.curdir,mmgen_tool)
  136. sys_cmd = [mmgen_tool, "-d",cfg['tmpdir'], name] + tool_args + kwargs.split()
  137. if extra_msg: extra_msg = "(%s)" % extra_msg
  138. full_name = " ".join([name]+kwargs.split()+extra_msg.split())
  139. if not silent:
  140. if opt.verbose:
  141. sys.stderr.write(green("Testing %s\nExecuting " % full_name))
  142. sys.stderr.write("%s\n" % cyan(repr(sys_cmd)))
  143. else:
  144. msg_r("Testing %-31s%s" % (full_name+":",""))
  145. import subprocess
  146. return subprocess.check_output(sys_cmd)
  147. def run_cmd_chk(self,name,f1,f2,kwargs="",extra_msg=""):
  148. idata = read_from_file(f1)[:-1]
  149. odata = read_from_file(f2)[:-1]
  150. ret = self.run_cmd(name,[odata],kwargs=kwargs,extra_msg=extra_msg)[:-1]
  151. vmsg("In: " + repr(odata))
  152. vmsg("Out: " + repr(ret))
  153. if ret == idata: ok()
  154. else:
  155. msg(red(
  156. "Error: values don't match:\nIn: %s\nOut: %s" % (repr(idata),repr(ret))))
  157. sys.exit(3)
  158. return ret
  159. def run_cmd_nochk(self,name,f1,kwargs=""):
  160. odata = read_from_file(f1)[:-1]
  161. ret = self.run_cmd(name,[odata],kwargs=kwargs)[:-1]
  162. vmsg("In: " + repr(odata))
  163. vmsg("Out: " + repr(ret))
  164. return ret
  165. def run_cmd_out(self,name,carg=None,Return=False,kwargs="",fn_idx="",extra_msg=""):
  166. if carg: write_to_tmpfile(cfg,"%s%s.in" % (name,fn_idx),carg+"\n")
  167. ret = self.run_cmd(name,[carg] if carg else [],kwargs=kwargs,extra_msg=extra_msg)
  168. if carg: vmsg("In: " + repr(carg))
  169. vmsg("Out: " + repr(ret[:-1]))
  170. if ret:
  171. write_to_tmpfile(cfg,"%s%s.out" % (name,fn_idx),ret)
  172. if Return: return ret
  173. else: ok()
  174. else:
  175. msg(red("Error for command '%s'" % name))
  176. sys.exit(3)
  177. def run_cmd_randfileinput(self,name):
  178. s = os.urandom(128)
  179. fn = name+".in"
  180. write_to_tmpfile(cfg,fn,s)
  181. ret = self.run_cmd(name,[get_tmpfile_fn(cfg,fn)])
  182. fn = name+".out"
  183. write_to_tmpfile(cfg,fn,ret)
  184. ok()
  185. vmsg("Returned: %s" % ret)
  186. def str2id6(self,name):
  187. s = getrandstr(120,no_space=True)
  188. s2 = " %s %s %s %s %s " % (s[:3],s[3:9],s[9:29],s[29:50],s[50:120])
  189. ret1 = self.run_cmd(name,[s],extra_msg="unspaced input"); ok()
  190. ret2 = self.run_cmd(name,[s2],extra_msg="spaced input")
  191. cmp_or_die(ret1,ret2)
  192. vmsg("Returned: %s" % ret1)
  193. def mn_rand128(self,name):
  194. self.run_cmd_out(name)
  195. def mn_rand192(self,name):
  196. self.run_cmd_out(name)
  197. def mn_rand256(self,name):
  198. self.run_cmd_out(name)
  199. def mn_stats(self,name):
  200. self.run_cmd_out(name)
  201. def mn_printlist(self,name):
  202. self.run_cmd(name,[])
  203. ok()
  204. def id6(self,name): self.run_cmd_randfileinput(name)
  205. def id8(self,name): self.run_cmd_randfileinput(name)
  206. def hexdump(self,name): self.run_cmd_randfileinput(name)
  207. def unhexdump(self,name,fn1,fn2):
  208. ret = self.run_cmd(name,[fn2])
  209. orig = read_from_file(fn1)
  210. cmp_or_die(orig,ret)
  211. def rand2file(self,name):
  212. of = name + ".out"
  213. dlen = 1024
  214. self.run_cmd(name,[of,str(1024),"threads=4","silent=1"])
  215. d = read_from_tmpfile(cfg,of)
  216. cmp_or_die(dlen,len(d))
  217. def strtob58(self,name): self.run_cmd_out(name,getrandstr(16))
  218. def sha256x2(self,name): self.run_cmd_out(name,getrandstr(16))
  219. def hexreverse(self,name): self.run_cmd_out(name,getrandhex(24))
  220. def hexlify(self,name): self.run_cmd_out(name,getrandstr(24))
  221. def b58tostr(self,name,f1,f2): self.run_cmd_chk(name,f1,f2)
  222. def hextob58(self,name): self.run_cmd_out(name,getrandhex(32))
  223. def b58tohex(self,name,f1,f2): self.run_cmd_chk(name,f1,f2)
  224. def hextob32(self,name): self.run_cmd_out(name,getrandhex(24))
  225. def b32tohex(self,name,f1,f2): self.run_cmd_chk(name,f1,f2)
  226. def b58randenc(self,name):
  227. ret = self.run_cmd_out(name,Return=True)
  228. ok_or_die(ret[:-1],is_b58_str,"base 58 string")
  229. def randhex(self,name):
  230. ret = self.run_cmd_out(name,Return=True)
  231. ok_or_die(ret[:-1],binascii.unhexlify,"hex string")
  232. def randwif(self,name):
  233. for n,k in enumerate(["","compressed=1"]):
  234. ret = self.run_cmd_out(name,kwargs=k,Return=True,fn_idx=n+1)
  235. ok_or_die(ret[:-1],is_wif,"WIF key")
  236. def randpair(self,name):
  237. for n,k in enumerate(["","compressed=1"]):
  238. wif,addr = self.run_cmd_out(name,kwargs=k,Return=True,fn_idx=n+1).split()
  239. ok_or_die(wif,is_wif,"WIF key",skip_ok=True)
  240. ok_or_die(addr,is_btc_addr,"Bitcoin address")
  241. def hex2wif(self,name,f1,f2,f3,f4):
  242. for n,fi,fo,k in (1,f1,f2,""),(2,f3,f4,"compressed=1"):
  243. ret = self.run_cmd_chk(name,fi,fo,kwargs=k)
  244. def wif2hex(self,name,f1,f2):
  245. for n,f,k in (1,f1,""),(2,f2,"compressed=1"):
  246. wif = read_from_file(f).split()[0]
  247. self.run_cmd_out(name,wif,kwargs=k,fn_idx=n)
  248. def wif2addr(self,name,f1,f2):
  249. for n,f,k in (1,f1,""),(2,f2,"compressed=1"):
  250. wif = read_from_file(f).split()[0]
  251. self.run_cmd_out(name,wif,kwargs=k,fn_idx=n)
  252. def addr2hexaddr(self,name,f1,f2):
  253. for n,f,m in (1,f1,""),(2,f2,"from compressed"):
  254. addr = read_from_file(f).split()[-1]
  255. self.run_cmd_out(name,addr,fn_idx=n,extra_msg=m)
  256. def hexaddr2addr(self,name,f1,f2,f3,f4):
  257. for n,fi,fo,m in (1,f1,f2,""),(2,f3,f4,"from compressed"):
  258. self.run_cmd_chk(name,fi,fo,extra_msg=m)
  259. def privhex2addr(self,name,f1,f2):
  260. key1 = read_from_file(f1)
  261. key2 = read_from_file(f2)
  262. for n,args in enumerate([[key1],[key2,"compressed=1"]]):
  263. ret = self.run_cmd(name,args).rstrip()
  264. iaddr = read_from_tmpfile(cfg,"randpair%s.out" % (n+1)).split()[-1]
  265. cmp_or_die(iaddr,ret)
  266. def hex2mn(self,name):
  267. for n,size,m in(1,16,"128-bit"),(2,24,"192-bit"),(3,32,"256-bit"):
  268. hexnum = getrandhex(size)
  269. self.run_cmd_out(name,hexnum,fn_idx=n,extra_msg=m)
  270. def mn2hex(self,name,f1,f2,f3,f4,f5,f6):
  271. for f_i,f_o,m in (f1,f2,"128-bit"),(f3,f4,"192-bit"),(f5,f6,"256-bit"):
  272. self.run_cmd_chk(name,f_i,f_o,extra_msg=m)
  273. # main()
  274. import time
  275. start_time = int(time.time())
  276. ts = MMGenToolTestSuite()
  277. mk_tmpdir(cfg)
  278. if cmd_args:
  279. if len(cmd_args) != 1:
  280. msg("Only one command may be specified")
  281. sys.exit(1)
  282. cmd = cmd_args[0]
  283. if cmd in cmd_data:
  284. msg("Running tests for %s:" % cmd_data[cmd]['desc'])
  285. ts.do_cmds(cmd)
  286. elif cmd == "clean":
  287. cleandir(cfg['tmpdir'])
  288. sys.exit(0)
  289. else:
  290. msg("'%s': unrecognized command" % cmd)
  291. sys.exit(1)
  292. else:
  293. cleandir(cfg['tmpdir'])
  294. for cmd in cmd_data:
  295. msg("Running tests for %s:" % cmd_data[cmd]['desc'])
  296. ts.do_cmds(cmd)
  297. if cmd is not cmd_data.keys()[-1]: msg("")
  298. t = int(time.time()) - start_time
  299. msg(green(
  300. "All requested tests finished OK, elapsed time: %02i:%02i" % (t/60,t%60)))