class MMGenPexpect(object):
NL = '\r\n'
if g.platform == 'linux' and opt.popen_spawn:
import atexit
atexit.register(lambda: os.system('stty sane'))
NL = '\n'
def __init__(self,name,mmgen_cmd,cmd_args,desc,no_output=False,passthru_args=[],msg_only=False,no_msg=False):
cmd_args = ['--{}{}'.format(k.replace('_','-'),
'='+getattr(opt,k) if getattr(opt,k) != True else ''
) for k in passthru_args if getattr(opt,k)] \
+ ['--data-dir='+data_dir] + cmd_args
if g.platform == 'win': cmd,args = 'python',[mmgen_cmd]+cmd_args
else: cmd,args = mmgen_cmd,cmd_args
for i in args:
if type(i) not in (str,unicode):
m1 = 'Error: missing input files in cmd line?:'
m2 = '\nName: {}\nCmd: {}\nCmd args: {}'
die(2,(m1+m2).format(name,cmd,args))
if opt.popen_spawn:
args = [u'{q}{}{q}'.format(a,q="'" if ' ' in a else '') for a in args]
cmd_str = u'{} {}'.format(cmd,u' '.join(args)).replace('\\','/')
if opt.coverage:
fs = 'python -m trace --count --coverdir={} --file={} {c}'
cmd_str = fs.format(*init_coverage(),c=cmd_str)
if opt.log:
log_fd.write(cmd_str+'\n')
if not no_msg:
if opt.verbose or opt.print_cmdline or opt.exact_output:
clr1,clr2,eol = ((green,cyan,'\n'),(nocolor,nocolor,' '))[bool(opt.print_cmdline)]
sys.stderr.write(green('Testing: {}\n'.format(desc)))
if not msg_only:
sys.stderr.write(clr1(u'Executing {}{}'.format(clr2(cmd_str),eol)))
else:
m = 'Testing {}: '.format(desc)
msg_r(m)
if msg_only: return
if opt.direct_exec:
msg('')
from subprocess import call,check_output
f = (call,check_output)[bool(no_output)]
ret = f([cmd] + args)
if f == call and ret != 0:
die(1,red('ERROR: process returned a non-zero exit status ({})'.format(ret)))
else:
if opt.traceback:
cmd,args = g.traceback_cmd,[cmd]+args
cmd_str = g.traceback_cmd + ' ' + cmd_str
# Msg('\ncmd_str: {}'.format(cmd_str))
if opt.popen_spawn:
self.p = PopenSpawn(cmd_str.encode('utf8'))
else:
self.p = pexpect.spawn(cmd,args)
if opt.exact_output: self.p.logfile = sys.stdout
def ok(self,exit_val=0):
ret = self.p.wait()
# Msg('expect: {} got: {}'.format(exit_val,ret))
if ret != exit_val and not opt.coverage:
die(1,red('test.py: spawned program exited with value {}'.format(ret)))
if opt.profile: return
if opt.verbose or opt.exact_output:
sys.stderr.write(green('OK\n'))
else: msg(' OK')
def cmp_or_die(self,s,t,skip_ok=False,exit_val=0):
ret = self.p.wait()
if ret != exit_val:
rdie(1,'test.py: spawned program exited with value {}'.format(ret))
if s == t:
if not skip_ok: ok()
else:
fs = 'ERROR: recoded data:\n{}\ndiffers from original data:\n{}'
rdie(3,fs.format(repr(t),repr(s)))
def license(self):
if 'MMGEN_NO_LICENSE' in os.environ: return
p = "'w' for conditions and warranty info, or 'c' to continue: "
my_expect(self.p,p,'c')
def label(self,label='Test Label'):
p = 'Enter a wallet label, or hit ENTER for no label: '
my_expect(self.p,p,label+'\n')
def usr_rand_out(self,saved=False):
fs = 'Generating encryption key from OS random data plus {}user-supplied entropy'
my_expect(self.p,fs.format(('','saved ')[saved]))
def usr_rand(self,num_chars):
if opt.usr_random:
self.interactive()
my_send(self.p,'\n')
else:
rand_chars = list(getrandstr(num_chars,no_space=True))
my_expect(self.p,'symbols left: ','x')
try:
vmsg_r('SEND ')
while self.p.expect('left: ',0.1) == 0:
ch = rand_chars.pop(0)
msg_r(yellow(ch)+' ' if opt.verbose else '+')
self.p.send(ch)
except:
vmsg('EOT')
my_expect(self.p,'ENTER to continue: ','\n')
def passphrase_new(self,desc,passphrase):
my_expect(self.p,'Enter passphrase for {}: '.format(desc),passphrase+'\n')
my_expect(self.p,'Repeat passphrase: ',passphrase+'\n')
def passphrase(self,desc,passphrase,pwtype=''):
if pwtype: pwtype += ' '
my_expect(self.p,
'Enter {}passphrase for {}.*?: '.format(pwtype,desc),
passphrase+'\n',regex=True)
def hash_preset(self,desc,preset=''):
my_expect(self.p,'Enter hash preset for {}'.format(desc))
my_expect(self.p,'or hit ENTER .*?:',str(preset)+'\n',regex=True)
def written_to_file(self,desc,overwrite_unlikely=False,query='Overwrite? ',oo=False):
s1 = '{} written to file '.format(desc)
s2 = query + "Type uppercase 'YES' to confirm: "
ret = my_expect(self.p,([s1,s2],s1)[overwrite_unlikely])
if ret == 1:
my_send(self.p,'YES\n')
# if oo:
outfile = self.expect_getend("Overwriting file '").rstrip("'").decode('utf8')
return outfile
# else:
# ret = my_expect(self.p,s1)
self.expect(self.NL,nonl=True)
outfile = self.p.before.strip().strip("'").decode('utf8')
if opt.debug_pexpect: rmsg('Outfile [{}]'.format(outfile))
vmsg(u'{} file: {}'.format(desc,cyan(outfile.replace("'",''))))
return outfile
def no_overwrite(self):
self.expect("Overwrite? Type uppercase 'YES' to confirm: ",'\n')
self.expect('Exiting at user request')
def tx_view(self,view=None):
repl = { 'terse':'t', 'full':'v' }[view] if view else 'n'
my_expect(self.p,r'View .*?transaction.*? \(y\)es, \(N\)o, pager \(v\)iew.*?: ',repl,regex=True)
if repl == 't':
my_expect(self.p,r'any key to continue: ','\n')
def expect_getend(self,s,regex=False):
ret = self.expect(s,regex=regex,nonl=True)
debug_pexpect_msg(self.p)
# end = self.readline().strip()
# readline() of partial lines doesn't work with PopenSpawn, so do this instead:
self.expect(self.NL,nonl=True,silent=True)
debug_pexpect_msg(self.p)
end = self.p.before
if not g.debug:
vmsg(' ==> {}'.format(cyan(end)))
return end
def interactive(self):
return self.p.interact() # interact() not available with popen_spawn
def kill(self,signal):
return self.p.kill(signal)
def logfile(self,arg):
self.p.logfile = arg
def expect(self,*args,**kwargs):
return my_expect(self.p,*args,**kwargs)
def send(self,*args,**kwargs):
return my_send(self.p,*args,**kwargs)
# def readline(self):
# return self.p.readline()
# def readlines(self):
# return [l.rstrip()+'\n' for l in self.p.readlines()]
def read(self,n=None):
return self.p.read(n)
def close(self):
if not opt.popen_spawn:
self.p.close()
class MMGenPexpect(object):
NL = '\r\n'
if g.platform == 'linux' and opt.popen_spawn:
import atexit
atexit.register(lambda: os.system('stty sane'))
NL = '\n'
data_dir = os.path.join('test', 'data_dir')
add_spawn_args = ' '.join([
'{} {}'.format('--' + k.replace('_', '-'),
getattr(opt, k) if getattr(opt, k) != True else '')
for k in ('testnet', 'rpc_host', 'rpc_port', 'regtest', 'coin')
if getattr(opt, k)
]).split()
add_spawn_args += ['--data-dir', data_dir]
def __init__(self, name, mmgen_cmd, cmd_args, desc, no_output=False):
cmd_args = self.add_spawn_args + cmd_args
cmd = (('./', '')[bool(opt.system)] + mmgen_cmd,
'python')[g.platform == 'win']
args = (cmd_args, [mmgen_cmd] + cmd_args)[g.platform == 'win']
for i in args:
if type(i) not in (str, unicode):
m1 = 'Error: missing input files in cmd line?:'
m2 = '\nName: {}\nCmd: {}\nCmd args: {}'
die(2, (m1 + m2).format(name, cmd, args))
if opt.popen_spawn:
args = [("'" + a + "'" if ' ' in a else a) for a in args]
cmd_str = '{} {}'.format(cmd, ' '.join(args))
if opt.popen_spawn:
cmd_str = cmd_str.replace('\\', '/')
if opt.log:
log_fd.write(cmd_str + '\n')
if opt.verbose or opt.print_cmdline or opt.exact_output:
clr1, clr2, eol = ((green, cyan, '\n'),
(nocolor, nocolor,
' '))[bool(opt.print_cmdline)]
sys.stderr.write(green('Testing: {}\n'.format(desc)))
sys.stderr.write(clr1('Executing {}{}'.format(clr2(cmd_str), eol)))
else:
m = 'Testing %s: ' % desc
msg_r(m)
if mmgen_cmd == '': return
if opt.direct_exec:
msg('')
from subprocess import call, check_output
f = (call, check_output)[bool(no_output)]
ret = f([cmd] + args)
if f == call and ret != 0:
m = 'ERROR: process returned a non-zero exit status (%s)'
die(1, red(m % ret))
else:
if opt.traceback:
cmd, args = g.traceback_cmd, [cmd] + args
cmd_str = g.traceback_cmd + ' ' + cmd_str
if opt.popen_spawn:
self.p = PopenSpawn(cmd_str)
else:
self.p = pexpect.spawn(cmd, args)
if opt.exact_output: self.p.logfile = sys.stdout
def ok(self, exit_val=0):
ret = self.p.wait()
if ret != exit_val:
die(
1,
red('test.py: spawned program exited with value {}'.format(
ret)))
if opt.profile: return
if opt.verbose or opt.exact_output:
sys.stderr.write(green('OK\n'))
else:
msg(' OK')
def cmp_or_die(self, s, t, skip_ok=False, exit_val=0):
ret = self.p.wait()
if ret != exit_val:
die(
1,
red('test.py: spawned program exited with value {}'.format(
ret)))
if s == t:
if not skip_ok: ok()
else:
sys.stderr.write(
red('ERROR: recoded data:\n%s\ndiffers from original data:\n%s\n'
% (repr(t), repr(s))))
sys.exit(3)
def license(self):
if 'MMGEN_NO_LICENSE' in os.environ: return
p = "'w' for conditions and warranty info, or 'c' to continue: "
my_expect(self.p, p, 'c')
def label(self, label='Test Label'):
p = 'Enter a wallet label, or hit ENTER for no label: '
my_expect(self.p, p, label + '\n')
def usr_rand_out(self, saved=False):
m = '%suser-supplied entropy' % (('', 'saved ')[saved])
my_expect(self.p,
'Generating encryption key from OS random data plus ' + m)
def usr_rand(self, num_chars):
if opt.usr_random:
self.interactive()
my_send(self.p, '\n')
else:
rand_chars = list(getrandstr(num_chars, no_space=True))
my_expect(self.p, 'symbols left: ', 'x')
try:
vmsg_r('SEND ')
while self.p.expect('left: ', 0.1) == 0:
ch = rand_chars.pop(0)
msg_r(yellow(ch) + ' ' if opt.verbose else '+')
self.p.send(ch)
except:
vmsg('EOT')
my_expect(self.p, 'ENTER to continue: ', '\n')
def passphrase_new(self, desc, passphrase):
my_expect(self.p, ('Enter passphrase for %s: ' % desc),
passphrase + '\n')
my_expect(self.p, 'Repeat passphrase: ', passphrase + '\n')
def passphrase(self, desc, passphrase, pwtype=''):
if pwtype: pwtype += ' '
my_expect(self.p, ('Enter %spassphrase for %s.*?: ' % (pwtype, desc)),
passphrase + '\n',
regex=True)
def hash_preset(self, desc, preset=''):
my_expect(self.p, ('Enter hash preset for %s' % desc))
my_expect(self.p, ('or hit ENTER .*?:'),
str(preset) + '\n',
regex=True)
def written_to_file(self,
desc,
overwrite_unlikely=False,
query='Overwrite? ',
oo=False):
s1 = '%s written to file ' % desc
s2 = query + "Type uppercase 'YES' to confirm: "
ret = my_expect(self.p, ([s1, s2], s1)[overwrite_unlikely])
if ret == 1:
my_send(self.p, 'YES\n')
# if oo:
outfile = self.expect_getend("Overwriting file '").rstrip("'")
return outfile
# else:
# ret = my_expect(self.p,s1)
self.expect(self.NL, nonl=True)
outfile = self.p.before.strip().strip("'")
if opt.debug_pexpect: msgred('Outfile [%s]' % outfile)
vmsg('%s file: %s' % (desc, cyan(outfile.replace("'", ''))))
return outfile
def no_overwrite(self):
self.expect("Overwrite? Type uppercase 'YES' to confirm: ", '\n')
self.expect('Exiting at user request')
def tx_view(self):
my_expect(
self.p,
r'View .*?transaction.*? \(y\)es, \(N\)o, pager \(v\)iew.*?: ',
'\n',
regex=True)
def expect_getend(self, s, regex=False):
ret = self.expect(s, regex=regex, nonl=True)
debug_pexpect_msg(self.p)
# end = self.readline().strip()
# readline() of partial lines doesn't work with PopenSpawn, so do this instead:
self.expect(self.NL, nonl=True, silent=True)
debug_pexpect_msg(self.p)
end = self.p.before
vmsg(' ==> %s' % cyan(end))
return end
def interactive(self):
return self.p.interact() # interact() not available with popen_spawn
def logfile(self, arg):
self.p.logfile = arg
def expect(self, *args, **kwargs):
return my_expect(self.p, *args, **kwargs)
def send(self, *args, **kwargs):
return my_send(self.p, *args, **kwargs)
# def readline(self):
# return self.p.readline()
# def readlines(self):
# return [l.rstrip()+'\n' for l in self.p.readlines()]
def read(self, n=None):
return self.p.read(n)
def close(self):
if not opt.popen_spawn:
self.p.close()
class MMGenPexpect(object):
def __init__(self, args, no_output=False):
if opt.direct_exec:
msg('')
from subprocess import call, check_output
f = (call, check_output)[bool(no_output)]
ret = f([args[0]] + args[1:])
if f == call and ret != 0:
die(
1,
red('ERROR: process returned a non-zero exit status ({})'.
format(ret)))
else:
if opt.pexpect_spawn:
self.p = pexpect.spawn(args[0], args[1:], encoding='utf8')
self.p.delaybeforesend = 0
else:
self.p = PopenSpawn(args, encoding='utf8')
# self.p.delaybeforesend = 0 # TODO: try this here too
if opt.exact_output: self.p.logfile = sys.stdout
self.req_exit_val = 0
self.skip_ok = False
self.timeout = int(opt.pexpect_timeout or 0) or (60, 5)[bool(
opt.debug_pexpect)]
self.sent_value = None
def do_decrypt_ka_data(self,
hp,
pw,
desc='key-address data',
check=True,
have_yes_opt=False):
# self.hash_preset(desc,hp)
self.passphrase(desc, pw)
if not have_yes_opt:
self.expect('Check key-to-address validity? (y/N): ',
('n', 'y')[check])
def view_tx(self, view):
self.expect('View.* transaction.*\? .*: ', view, regex=True)
if view not in 'n\n':
self.expect('to continue: ', '\n')
def do_comment(self, add_comment, has_label=False):
p = ('Add a comment to transaction',
'Edit transaction comment')[has_label]
self.expect('{}? (y/N): '.format(p), ('n', 'y')[bool(add_comment)])
if add_comment:
self.expect('Comment: ', add_comment + '\n')
def ok(self):
ret = self.p.wait()
if ret != self.req_exit_val and not opt.coverage:
die(
1,
red('test.py: spawned program exited with value {}'.format(
ret)))
if opt.profile: return
if not self.skip_ok:
sys.stderr.write(
green('OK\n') if opt.exact_output or opt.verbose else (
' OK\n'))
return self
def license(self):
if 'MMGEN_NO_LICENSE' in os.environ: return
self.expect(
"'w' for conditions and warranty info, or 'c' to continue: ", 'c')
def label(self, label='Test Label (UTF-8) α'):
self.expect('Enter a wallet label, or hit ENTER for no label: ',
label + '\n')
def usr_rand_out(self, saved=False):
fs = 'Generating encryption key from OS random data plus {}user-supplied entropy'
self.expect(fs.format(('', 'saved ')[saved]))
def usr_rand(self, num_chars):
if opt.usr_random:
self.interactive()
self.send('\n')
else:
rand_chars = list(getrandstr(num_chars, no_space=True))
vmsg_r('SEND ')
while rand_chars:
ch = rand_chars.pop(0)
msg_r(yellow(ch) + ' ' if opt.verbose else '+')
ret = self.expect('left: ', ch, delay=0.005)
self.expect('ENTER to continue: ', '\n')
def passphrase_new(self, desc, passphrase):
self.expect('Enter passphrase for {}: '.format(desc),
passphrase + '\n')
self.expect('Repeat passphrase: ', passphrase + '\n')
def passphrase(self, desc, passphrase, pwtype=''):
if pwtype: pwtype += ' '
self.expect('Enter {}passphrase for {}.*?: '.format(pwtype, desc),
passphrase + '\n',
regex=True)
def hash_preset(self, desc, preset=''):
self.expect('Enter hash preset for {}'.format(desc))
self.expect('or hit ENTER .*?:', str(preset) + '\n', regex=True)
def written_to_file(self,
desc,
overwrite_unlikely=False,
query='Overwrite? ',
oo=False):
s1 = '{} written to file '.format(desc)
s2 = query + "Type uppercase 'YES' to confirm: "
ret = self.expect(([s1, s2], s1)[overwrite_unlikely])
if ret == 1:
self.send('YES\n')
return self.expect_getend("Overwriting file '").rstrip("'")
self.expect(NL, nonl=True)
outfile = self.p.before.strip().strip("'")
if opt.debug_pexpect:
rmsg('Outfile [{}]'.format(outfile))
vmsg('{} file: {}'.format(desc, cyan(outfile.replace("'", ''))))
return outfile
def no_overwrite(self):
self.expect("Overwrite? Type uppercase 'YES' to confirm: ", '\n')
self.expect('Exiting at user request')
def expect_getend(self, s, regex=False):
ret = self.expect(s, regex=regex, nonl=True)
debug_pexpect_msg(self.p)
# readline() of partial lines doesn't work with PopenSpawn, so do this instead:
self.expect(NL, nonl=True, silent=True)
debug_pexpect_msg(self.p)
end = self.p.before.rstrip()
if not g.debug:
vmsg(' ==> {}'.format(cyan(end)))
return end
def interactive(self):
return self.p.interact() # interact() not available with popen_spawn
def kill(self, signal):
return self.p.kill(signal)
def expect(self,
s,
t='',
delay=None,
regex=False,
nonl=False,
silent=False):
delay = delay or (0, 0.3)[bool(opt.buf_keypress)]
if not silent:
if opt.verbose:
msg_r('EXPECT ' + yellow(str(s)))
elif not opt.exact_output:
msg_r('+')
try:
if s == '':
ret = 0
else:
f = (self.p.expect_exact, self.p.expect)[bool(regex)]
ret = f(s, self.timeout)
except pexpect.TIMEOUT:
if opt.debug_pexpect: raise
m1 = red('\nERROR. Expect {!r} timed out. Exiting\n'.format(s))
m2 = 'before: [{}]\n'.format(self.p.before)
m3 = 'sent value: [{}]'.format(
self.sent_value) if self.sent_value != None else ''
rdie(1, m1 + m2 + m3)
debug_pexpect_msg(self.p)
if opt.verbose and type(s) != str:
msg_r(' ==> {} '.format(ret))
if ret == -1:
rdie(1, 'Error. Expect returned {}'.format(ret))
else:
if t == '':
if not nonl and not silent: vmsg('')
else:
self.send(t, delay, s)
return ret
def send(self, t, delay=None, s=False):
self.sent_value = None
delay = delay or (0, 0.3)[bool(opt.buf_keypress)]
if delay: time.sleep(delay)
ret = self.p.send(t) # returns num bytes written
if ret:
self.sent_value = t
if delay: time.sleep(delay)
if opt.verbose:
ls = (' ', '')[bool(opt.debug or not s)]
es = (' ', '')[bool(s)]
msg('{}SEND {}{}'.format(
ls, es, yellow("'{}'".format(t.replace('\n', r'\n')))))
return ret
def read(self, n=-1):
return self.p.read(n)
def close(self):
if opt.pexpect_spawn:
self.p.close()
class MMGenPexpect(object):
def __init__(self,args,no_output=False):
if opt.direct_exec:
msg('')
from subprocess import call,check_output
f = (call,check_output)[bool(no_output)]
ret = f([args[0]] + args[1:])
if f == call and ret != 0:
die(1,red('ERROR: process returned a non-zero exit status ({})'.format(ret)))
else:
if opt.pexpect_spawn:
self.p = pexpect.spawn(args[0],args[1:],encoding='utf8')
self.p.delaybeforesend = 0
else:
self.p = PopenSpawn(args,encoding='utf8')
# self.p.delaybeforesend = 0 # TODO: try this here too
if opt.exact_output: self.p.logfile = sys.stdout
self.req_exit_val = 0
self.skip_ok = False
self.timeout = int(opt.pexpect_timeout or 0) or (60,5)[bool(opt.debug_pexpect)]
self.sent_value = None
def do_decrypt_ka_data(self,hp,pw,desc='key-address data',check=True,have_yes_opt=False):
# self.hash_preset(desc,hp)
self.passphrase(desc,pw)
if not have_yes_opt:
self.expect('Check key-to-address validity? (y/N): ',('n','y')[check])
def view_tx(self,view):
self.expect('View.* transaction.*\? .*: ',view,regex=True)
if view not in 'n\n':
self.expect('to continue: ','\n')
def do_comment(self,add_comment,has_label=False):
p = ('Add a comment to transaction','Edit transaction comment')[has_label]
self.expect('{}? (y/N): '.format(p),('n','y')[bool(add_comment)])
if add_comment:
self.expect('Comment: ',add_comment+'\n')
def ok(self):
ret = self.p.wait()
if ret != self.req_exit_val and not opt.coverage:
die(1,red('test.py: spawned program exited with value {}'.format(ret)))
if opt.profile: return
if not self.skip_ok:
sys.stderr.write(green('OK\n') if opt.exact_output or opt.verbose else (' OK\n'))
return self
def license(self):
if 'MMGEN_NO_LICENSE' in os.environ: return
self.expect("'w' for conditions and warranty info, or 'c' to continue: ",'c')
def label(self,label='Test Label (UTF-8) α'):
self.expect('Enter a wallet label, or hit ENTER for no label: ',label+'\n')
def usr_rand_out(self,saved=False):
fs = 'Generating encryption key from OS random data plus {}user-supplied entropy'
self.expect(fs.format(('','saved ')[saved]))
def usr_rand(self,num_chars):
if opt.usr_random:
self.interactive()
self.send('\n')
else:
rand_chars = list(getrandstr(num_chars,no_space=True))
vmsg_r('SEND ')
while rand_chars:
ch = rand_chars.pop(0)
msg_r(yellow(ch)+' ' if opt.verbose else '+')
ret = self.expect('left: ',ch,delay=0.005)
self.expect('ENTER to continue: ','\n')
def passphrase_new(self,desc,passphrase):
self.expect('Enter passphrase for {}: '.format(desc),passphrase+'\n')
self.expect('Repeat passphrase: ',passphrase+'\n')
def passphrase(self,desc,passphrase,pwtype=''):
if pwtype: pwtype += ' '
self.expect('Enter {}passphrase for {}.*?: '.format(pwtype,desc),passphrase+'\n',regex=True)
def hash_preset(self,desc,preset=''):
self.expect('Enter hash preset for {}'.format(desc))
self.expect('or hit ENTER .*?:',str(preset)+'\n',regex=True)
def written_to_file(self,desc,overwrite_unlikely=False,query='Overwrite? ',oo=False):
s1 = '{} written to file '.format(desc)
s2 = query + "Type uppercase 'YES' to confirm: "
ret = self.expect(([s1,s2],s1)[overwrite_unlikely])
if ret == 1:
self.send('YES\n')
return self.expect_getend("Overwriting file '").rstrip("'")
self.expect(NL,nonl=True)
outfile = self.p.before.strip().strip("'")
if opt.debug_pexpect:
rmsg('Outfile [{}]'.format(outfile))
vmsg('{} file: {}'.format(desc,cyan(outfile.replace("'",''))))
return outfile
def no_overwrite(self):
self.expect("Overwrite? Type uppercase 'YES' to confirm: ",'\n')
self.expect('Exiting at user request')
def expect_getend(self,s,regex=False):
ret = self.expect(s,regex=regex,nonl=True)
debug_pexpect_msg(self.p)
# readline() of partial lines doesn't work with PopenSpawn, so do this instead:
self.expect(NL,nonl=True,silent=True)
debug_pexpect_msg(self.p)
end = self.p.before.rstrip()
if not g.debug:
vmsg(' ==> {}'.format(cyan(end)))
return end
def interactive(self):
return self.p.interact() # interact() not available with popen_spawn
def kill(self,signal):
return self.p.kill(signal)
def expect(self,s,t='',delay=None,regex=False,nonl=False,silent=False):
delay = delay or (0,0.3)[bool(opt.buf_keypress)]
if not silent:
if opt.verbose:
msg_r('EXPECT ' + yellow(str(s)))
elif not opt.exact_output: msg_r('+')
try:
if s == '':
ret = 0
else:
f = (self.p.expect_exact,self.p.expect)[bool(regex)]
ret = f(s,self.timeout)
except pexpect.TIMEOUT:
if opt.debug_pexpect: raise
m1 = red('\nERROR. Expect {!r} timed out. Exiting\n'.format(s))
m2 = 'before: [{}]\n'.format(self.p.before)
m3 = 'sent value: [{}]'.format(self.sent_value) if self.sent_value != None else ''
rdie(1,m1+m2+m3)
debug_pexpect_msg(self.p)
if opt.verbose and type(s) != str:
msg_r(' ==> {} '.format(ret))
if ret == -1:
rdie(1,'Error. Expect returned {}'.format(ret))
else:
if t == '':
if not nonl and not silent: vmsg('')
else:
self.send(t,delay,s)
return ret
def send(self,t,delay=None,s=False):
self.sent_value = None
delay = delay or (0,0.3)[bool(opt.buf_keypress)]
if delay: time.sleep(delay)
ret = self.p.send(t) # returns num bytes written
if ret:
self.sent_value = t
if delay: time.sleep(delay)
if opt.verbose:
ls = (' ','')[bool(opt.debug or not s)]
es = (' ','')[bool(s)]
msg('{}SEND {}{}'.format(ls,es,yellow("'{}'".format(t.replace('\n',r'\n')))))
return ret
def read(self,n=-1):
return self.p.read(n)
def close(self):
if opt.pexpect_spawn:
self.p.close()
class MMGenPexpect(object):
NL = '\r\n'
if g.platform == 'linux' and opt.popen_spawn:
import atexit
atexit.register(lambda: os.system('stty sane'))
NL = '\n'
def __init__(self,name,mmgen_cmd,cmd_args,desc,no_output=False,passthru_args=[],msg_only=False):
cmd_args = ['--{}{}'.format(k.replace('_','-'),
'='+getattr(opt,k) if getattr(opt,k) != True else ''
) for k in passthru_args if getattr(opt,k)] \
+ ['--data-dir='+os.path.join('test','data_dir')] + cmd_args
if g.platform == 'win': cmd,args = 'python',[mmgen_cmd]+cmd_args
else: cmd,args = mmgen_cmd,cmd_args
for i in args:
if type(i) not in (str,unicode):
m1 = 'Error: missing input files in cmd line?:'
m2 = '\nName: {}\nCmd: {}\nCmd args: {}'
die(2,(m1+m2).format(name,cmd,args))
if opt.popen_spawn:
args = [(a,"'{}'".format(a))[' ' in a] for a in args]
cmd_str = '{} {}'.format(cmd,' '.join(args)).replace('\\','/')
if opt.log:
log_fd.write(cmd_str+'\n')
if opt.verbose or opt.print_cmdline or opt.exact_output:
clr1,clr2,eol = ((green,cyan,'\n'),(nocolor,nocolor,' '))[bool(opt.print_cmdline)]
sys.stderr.write(green('Testing: {}\n'.format(desc)))
if not msg_only:
sys.stderr.write(clr1('Executing {}{}'.format(clr2(cmd_str),eol)))
else:
m = 'Testing %s: ' % desc
msg_r(m)
if msg_only: return
if opt.direct_exec:
msg('')
from subprocess import call,check_output
f = (call,check_output)[bool(no_output)]
ret = f([cmd] + args)
if f == call and ret != 0:
m = 'ERROR: process returned a non-zero exit status (%s)'
die(1,red(m % ret))
else:
if opt.traceback:
cmd,args = g.traceback_cmd,[cmd]+args
cmd_str = g.traceback_cmd + ' ' + cmd_str
# Msg('\ncmd_str: {}'.format(cmd_str))
if opt.popen_spawn:
self.p = PopenSpawn(cmd_str)
else:
self.p = pexpect.spawn(cmd,args)
if opt.exact_output: self.p.logfile = sys.stdout
def ok(self,exit_val=0):
ret = self.p.wait()
# Msg('expect: {} got: {}'.format(exit_val,ret))
if ret != exit_val:
die(1,red('test.py: spawned program exited with value {}'.format(ret)))
if opt.profile: return
if opt.verbose or opt.exact_output:
sys.stderr.write(green('OK\n'))
else: msg(' OK')
def cmp_or_die(self,s,t,skip_ok=False,exit_val=0):
ret = self.p.wait()
if ret != exit_val:
die(1,red('test.py: spawned program exited with value {}'.format(ret)))
if s == t:
if not skip_ok: ok()
else:
sys.stderr.write(red(
'ERROR: recoded data:\n%s\ndiffers from original data:\n%s\n' %
(repr(t),repr(s))))
sys.exit(3)
def license(self):
if 'MMGEN_NO_LICENSE' in os.environ: return
p = "'w' for conditions and warranty info, or 'c' to continue: "
my_expect(self.p,p,'c')
def label(self,label='Test Label'):
p = 'Enter a wallet label, or hit ENTER for no label: '
my_expect(self.p,p,label+'\n')
def usr_rand_out(self,saved=False):
m = '%suser-supplied entropy' % (('','saved ')[saved])
my_expect(self.p,'Generating encryption key from OS random data plus ' + m)
def usr_rand(self,num_chars):
if opt.usr_random:
self.interactive()
my_send(self.p,'\n')
else:
rand_chars = list(getrandstr(num_chars,no_space=True))
my_expect(self.p,'symbols left: ','x')
try:
vmsg_r('SEND ')
while self.p.expect('left: ',0.1) == 0:
ch = rand_chars.pop(0)
msg_r(yellow(ch)+' ' if opt.verbose else '+')
self.p.send(ch)
except:
vmsg('EOT')
my_expect(self.p,'ENTER to continue: ','\n')
def passphrase_new(self,desc,passphrase):
my_expect(self.p,('Enter passphrase for %s: ' % desc), passphrase+'\n')
my_expect(self.p,'Repeat passphrase: ', passphrase+'\n')
def passphrase(self,desc,passphrase,pwtype=''):
if pwtype: pwtype += ' '
my_expect(self.p,('Enter %spassphrase for %s.*?: ' % (pwtype,desc)),
passphrase+'\n',regex=True)
def hash_preset(self,desc,preset=''):
my_expect(self.p,('Enter hash preset for %s' % desc))
my_expect(self.p,('or hit ENTER .*?:'), str(preset)+'\n',regex=True)
def written_to_file(self,desc,overwrite_unlikely=False,query='Overwrite? ',oo=False):
s1 = '%s written to file ' % desc
s2 = query + "Type uppercase 'YES' to confirm: "
ret = my_expect(self.p,([s1,s2],s1)[overwrite_unlikely])
if ret == 1:
my_send(self.p,'YES\n')
# if oo:
outfile = self.expect_getend("Overwriting file '").rstrip("'")
return outfile
# else:
# ret = my_expect(self.p,s1)
self.expect(self.NL,nonl=True)
outfile = self.p.before.strip().strip("'")
if opt.debug_pexpect: msgred('Outfile [%s]' % outfile)
vmsg('%s file: %s' % (desc,cyan(outfile.replace("'",''))))
return outfile
def no_overwrite(self):
self.expect("Overwrite? Type uppercase 'YES' to confirm: ",'\n')
self.expect('Exiting at user request')
def tx_view(self):
my_expect(self.p,r'View .*?transaction.*? \(y\)es, \(N\)o, pager \(v\)iew.*?: ','\n',regex=True)
def expect_getend(self,s,regex=False):
ret = self.expect(s,regex=regex,nonl=True)
debug_pexpect_msg(self.p)
# end = self.readline().strip()
# readline() of partial lines doesn't work with PopenSpawn, so do this instead:
self.expect(self.NL,nonl=True,silent=True)
debug_pexpect_msg(self.p)
end = self.p.before
vmsg(' ==> %s' % cyan(end))
return end
def interactive(self):
return self.p.interact() # interact() not available with popen_spawn
def kill(self,signal):
return self.p.kill(signal)
def logfile(self,arg):
self.p.logfile = arg
def expect(self,*args,**kwargs):
return my_expect(self.p,*args,**kwargs)
def send(self,*args,**kwargs):
return my_send(self.p,*args,**kwargs)
# def readline(self):
# return self.p.readline()
# def readlines(self):
# return [l.rstrip()+'\n' for l in self.p.readlines()]
def read(self,n=None):
return self.p.read(n)
def close(self):
if not opt.popen_spawn:
self.p.close()