mmgen/mmgen-wallet
1
Fork 0
Code Releases 28 Wiki Activity

new test: objattrtest.py: test objects' immutable attributes

Browse source
This commit is contained in:
The MMGen Project 2019-10-19 15:22:30 +00:00
commit 3224b9c7d2
Signed by: mmgen
GPG key ID: 3F8B1861E32B7DA2
5 changed files with 385 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

164
test/objattrtest.py Executable file
View file

@ -0,0 +1,164 @@
#!/usr/bin/env python3
#
# mmgen = Multi-Mode GENerator, command-line Bitcoin cold storage solution
# Copyright (C)2013-2019 The MMGen Project <mmgen@tuta.io>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
"""
test/objattrtest.py: Test immutable attributes of MMGen data objects
"""
# TODO: test 'typeconv' during instance creation
import sys,os
pn = os.path.dirname(sys.argv[0])
os.chdir(os.path.join(pn,os.pardir))
sys.path.__setitem__(0,os.path.abspath(os.curdir))
os.environ['MMGEN_TEST_SUITE'] = '1'
# Import these _after_ local path's been added to sys.path
from test.objattrtest_py_d.oat_common import *
opts_data = {
'sets': [
('show_nonstandard_init', True, 'verbose', True),
('show_descriptor_type', True, 'verbose', True),
],
'text': {
'desc': 'Test immutable attributes of MMGen data objects',
'usage':'[options] [object]',
'options': """
-h, --help Print this help message
--, --longhelp Print help message for long options (common options)
-i, --show-nonstandard-init Display non-standard attribute initialization info
-d, --show-descriptor-type Display the attribute's descriptor type
-v, --verbose Produce more verbose output
"""
}
}
cmd_args = opts.init(opts_data)
init_coin(g.coin)
from mmgen.tw import *
pd = namedtuple('permission_bits', ['read_ok','delete_ok','reassign_ok'])
def parse_permbits(bits):
return pd(
bool(0b001 & bits), # read
bool(0b010 & bits), # delete
bool(0b100 & bits), # reassign
)
def get_descriptor_obj(objclass,attrname):
for o in (objclass,objclass.__bases__[0]): # assume there's only one base class
if attrname in o.__dict__:
return o.__dict__[attrname]
rdie(3,'unable to find descriptor {}.{}'.format(objclass.__name__,attrname))
def test_attr_perm(obj,attrname,perm_name,perm_value,dobj,attrval_type):
class SampleObjError(Exception): pass
pname = perm_name.replace('_ok','')
pstem = pname.rstrip('e')
try:
if perm_name == 'read_ok':
getattr(obj,attrname)
elif perm_name == 'reassign_ok':
try:
so = sample_objs[attrval_type.__name__]
except:
raise SampleObjError('unable to find sample object of type {!r}'.format(attrval_type.__name__))
# MMGenListItemAttr allows setting an attribute if its value is None
if type(dobj) == MMGenListItemAttr and getattr(obj,attrname) == None:
setattr(obj,attrname,so)
setattr(obj,attrname,so)
elif perm_name == 'delete_ok':
delattr(obj,attrname)
except SampleObjError as e:
rdie(2,'Test script error ({})'.format(e))
except Exception as e:
if perm_value == True:
fs = '{!r}: unable to {} attribute {!r}, though {}ing is allowed ({})'
rdie(2,fs.format(type(obj).__name__,pname,attrname,pstem,e))
else:
if perm_value == False:
fs = '{!r}: attribute {!r} is {n}able, though {n}ing is forbidden'
rdie(2,fs.format(type(obj).__name__,attrname,n=pstem))
def test_attr(data,obj,attrname,dobj,bits,attrval_type):
if hasattr(obj,attrname): # TODO
td_attrval_type = data.attrs[attrname][1]
if attrval_type not in (td_attrval_type,type(None)):
fs = '\nattribute {!r} of {!r} instance has incorrect type {!r} (should be {!r})'
rdie(2,fs.format(attrname,type(obj).__name__,attrval_type.__name__,td_attrval_type.__name__))
if hasattr(dobj,'__dict__'):
d = dobj.__dict__
bits = bits._asdict()
for k in ('reassign_ok','delete_ok'):
if k in d:
if d[k] != bits[k]:
fs = 'init value {iv}={a} for attr {n!r} does not match test data ({iv}={b})'
rdie(2,fs.format(iv=k,n=attrname,a=d[k],b=bits[k]))
if opt.verbose and d[k] == True:
msg_r(' {}={!r}'.format(k,d[k]))
if opt.show_nonstandard_init:
for k,v in (('typeconv',False),('no_type_check',True),('set_none_ok',True)):
if d[k] == v:
msg_r(' {}={}'.format(k,v))
def test_object(test_data,objname):
if '.' in objname:
on1,on2 = objname.split('.')
cls = getattr(globals()[on1],on2)
else:
cls = globals()[objname]
fs = 'Testing attribute ' + ('{!r:<15}{dt:13}' if opt.show_descriptor_type else '{!r}')
data = test_data[objname]
obj = cls(*data.args,**data.kwargs)
for attrname,adata in data.attrs.items():
dobj = get_descriptor_obj(type(obj),attrname)
if opt.verbose:
msg_r(fs.format(attrname,dt=type(dobj).__name__.replace('MMGen','')))
bits = parse_permbits(adata[0])
test_attr(data,obj,attrname,dobj,bits,adata[1])
for perm_name,perm_value in bits._asdict().items():
test_attr_perm(obj,attrname,perm_name,perm_value,dobj,adata[1])
vmsg('')
def do_loop():
import importlib
network = ('mainnet','testnet')[bool(g.testnet)]
modname = 'test.objattrtest_py_d.oat_{}_{}'.format(g.coin.lower(),network)
test_data = importlib.import_module(modname).tests
gmsg('Running immutable attribute tests for {} {}'.format(g.coin,network))
utests = cmd_args
for obj in test_data:
if utests and obj not in utests: continue
clr = blue if opt.verbose else nocolor
msg(clr('Testing {}'.format(obj)))
test_object(test_data,obj)
do_loop()

0
test/objattrtest_py_d/__init__.py Executable file
View file

164
test/objattrtest_py_d/oat_btc_mainnet.py Executable file
View file

@ -0,0 +1,164 @@
#!/usr/bin/env python3
#
# mmgen = Multi-Mode GENerator, command-line Bitcoin cold storage solution
# Copyright (C)2013-2019 The MMGen Project <mmgen@tuta.io>
"""
test.objattrtest_py_d.oat_btc_mainnet: BTC mainnet test vectors for MMGen data
objects
"""
from .oat_common import *
sample_objs.update({
'PrivKey': PrivKey(seed_bin,compressed=True,pubkey_type='std'),
'WifKey': WifKey('5HwzecKMWD82ppJK3qMKpC7ohXXAwcyAN5VgdJ9PLFaAzpBG4sX'),
'CoinAddr': CoinAddr('1111111111111111111114oLvT2'),
'BTCAmt': BTCAmt('0.01'),
'MMGenID': MMGenID('F00F00BB:B:1'),
'TwMMGenID': TwMMGenID('F00F00BB:S:23'),
})
tests = {
# addr.py
'AddrListEntry': atd({
'addr': (0b001, CoinAddr),
'idx': (0b001, AddrIdx),
'label': (0b101, TwComment),
'sec': (0b001, PrivKey),
# 'viewkey': (0b001, ViewKey), # TODO
# 'wallet_passwd': (0b001, WalletPassword), # TODO
},
[],
{}
),
'PasswordListEntry': atd({
'passwd': (0b001, str),
'idx': (0b001, AddrIdx),
'label': (0b101, TwComment),
'sec': (0b001, PrivKey),
},
[],
{'passwd':'ΑlphaΩmega', 'idx':1 },
),
# obj.py
'PrivKey': atd({
'compressed': (0b001, bool),
'wif': (0b001, WifKey),
},
[seed_bin],
{'compressed':True, 'pubkey_type':'std'},
),
'MMGenAddrType': atd({
'name': (0b001, str),
'pubkey_type': (0b001, str),
'compressed': (0b001, bool),
'gen_method': (0b001, str),
'addr_fmt': (0b001, str),
'wif_label': (0b001, str),
'extra_attrs': (0b001, tuple),
'desc': (0b001, str),
},
['S'],
{},
),
# seed.py
'SeedBase': atd({
'data': (0b001, bytes),
'sid': (0b001, SeedID),
},
[seed_bin],
{},
),
'SubSeed': atd({
'idx': (0b001, int),
'nonce': (0b001, int),
'ss_idx': (0b001, SubSeedIdx),
},
[sample_objs['SubSeedList'],1,1,'short'],
{},
),
'SeedShareList': atd({
'count': (0b001, SeedShareCount),
'id_str': (0b001, SeedSplitIDString),
},
[sample_objs['Seed'],sample_objs['SeedShareCount']],
{},
),
'SeedShareLast': atd({
'idx': (0b001, SeedShareIdx),
},
[sample_objs['SeedShareList']],
{},
),
'SeedShareMaster': atd({
'idx': (0b001, MasterShareIdx),
'nonce': (0b001, int),
},
[sample_objs['SeedShareList'],7,0],
{},
),
'SeedShareMasterJoining': atd({
'id_str': (0b001, SeedSplitIDString),
'count': (0b001, SeedShareCount),
},
[sample_objs['MasterShareIdx'], sample_objs['Seed'], 'foo', 2],
{},
),
# tw.py
'TwUnspentOutputs.MMGenTwUnspentOutput': atd({
'txid': (0b001, CoinTxID),
'vout': (0b001, int),
'amt': (0b001, BTCAmt),
'amt2': (0b001, BTCAmt),
'label': (0b101, TwComment),
'twmmid': (0b001, TwMMGenID),
'addr': (0b001, CoinAddr),
'confs': (0b001, int),
'scriptPubKey': (0b001, HexStr),
'days': (0b001, int),
'skip': (0b101, str),
},
[],
{
'amt':BTCAmt('0.01'),
'twmmid':'F00F00BB:B:17',
'addr':'1111111111111111111114oLvT2',
'confs': 100000,
'scriptPubKey':'ff',
},
),
# tx.py
'MMGenTxInput': atd({
'vout': (0b001, int),
'amt': (0b001, BTCAmt),
'label': (0b101, TwComment),
'mmid': (0b001, MMGenID),
'addr': (0b001, CoinAddr),
'confs': (0b001, int),
'txid': (0b001, CoinTxID),
'have_wif': (0b011, bool),
'scriptPubKey': (0b001, HexStr),
'sequence': (0b001, int),
},
[],
{ 'amt':BTCAmt('0.01'), 'addr':sample_objs['CoinAddr'] },
),
'MMGenTxOutput': atd({
'vout': (0b001, int),
'amt': (0b001, BTCAmt),
'label': (0b101, TwComment),
'mmid': (0b001, MMGenID),
'addr': (0b001, CoinAddr),
'confs': (0b001, int),
'txid': (0b001, CoinTxID),
'have_wif': (0b011, bool),
'is_chg': (0b001, bool),
},
[],
{ 'amt':BTCAmt('0.01'), 'addr':sample_objs['CoinAddr'] },
),
}
tests['MMGenPasswordType'] = atd(tests['MMGenAddrType'].attrs, ['P'], {})

53
test/objattrtest_py_d/oat_common.py Executable file
View file

@ -0,0 +1,53 @@
#!/usr/bin/env python3
#
# mmgen = Multi-Mode GENerator, command-line Bitcoin cold storage solution
# Copyright (C)2013-2019 The MMGen Project <mmgen@tuta.io>
"""
test.objattrtest_py_d.oat_common: shared data for MMGen data objects tests
"""
import os
from decimal import Decimal
from mmgen.obj import *
from mmgen.seed import *
from mmgen.protocol import *
from mmgen.addr import *
from mmgen.tx import *
from collections import namedtuple
atd = namedtuple('attrtest_entry',['attrs','args','kwargs'])
seed_bin = os.urandom(32)
# use the constructors here! otherwise reassignment test might fail when
# reassignment would otherwise succeed
sample_objs = {
'int': int(1),
'Decimal': Decimal('0.01'),
'NoneType': None,
'bool': bool(True),
'str': str('foo'),
'dict': dict({'a':1}),
'list': list([1]),
'tuple': tuple((1,2)),
'bytes': bytes(1),
'HexStr': HexStr('ff'),
'AddrIdx': AddrIdx(1),
'TwComment': TwComment('αω'),
'CoinTxID': CoinTxID('aa'*32),
'SeedID': SeedID(sid='F00F00BB'),
'Seed': Seed(seed_bin=seed_bin),
'SubSeedList': SubSeedList(Seed(seed_bin=seed_bin)),
'SubSeedIdx': SubSeedIdx('1S'),
'SeedSplitIDString': SeedSplitIDString('alice'),
'SeedShareList': SeedShareList(Seed(seed_bin=seed_bin),SeedShareCount(2)),
'SeedShareIdx': SeedShareIdx(1),
'SeedShareCount': SeedShareCount(2),
'MasterShareIdx': MasterShareIdx(7),
}

4
test/test-release.sh
View file

@ -21,6 +21,7 @@ export MMGEN_NO_LICENSE=1
export PYTHONPATH=.
test_py='test/test.py -n'
objtest_py='test/objtest.py'
objattrtest_py='test/objattrtest.py'
unit_tests_py='test/unit_tests.py --names --quiet'
tooltest_py='test/tooltest.py'
tooltest2_py='test/tooltest2.py --names'
@ -88,6 +89,7 @@ do
python="python3 -m trace --count --file=test/trace.acc --coverdir=test/trace"
unit_tests_py="$python $unit_tests_py"
objtest_py="$python $objtest_py"
objattrtest_py="$python $objattrtest_py"
gentest_py="$python $gentest_py"
mmgen_tool="$python $mmgen_tool"
mmgen_keygen="$python $mmgen_keygen" ;&
@ -107,6 +109,7 @@ do
tooltest_py+=" --verbose" tooltest2_py+=" --verbose"
gentest_py+=" --verbose" mmgen_tool+=" --verbose"
unit_tests_py="${unit_tests_py/--quiet/--verbose}"
objattrtest_py+=" --verbose"
scrambletest_py+=" --verbose" ;;
*) exit ;;
esac
@ -194,6 +197,7 @@ t_obj="
$objtest_py --coin=ltc
$objtest_py --coin=ltc --testnet=1
$objtest_py --coin=eth
$objattrtest_py
"
f_obj='Data object test complete'