def test_capture():
from syn.base_utils import capture, assign
from six.moves import cStringIO
oout = cStringIO()
oerr = cStringIO()
with assign(sys, 'stdout', oout):
with assign(sys, 'stderr', oerr):
print("Outside")
sys.stderr.write('Err1\n')
with capture() as (out, err):
print("Inside")
sys.stderr.write('Err!\n')
assert out.getvalue() == 'Inside\n'
assert err.getvalue() == 'Err!\n'
print("Outside2")
sys.stderr.write('Err2\n')
assert out.getvalue() == 'Inside\n'
assert err.getvalue() == 'Err!\n'
print("Outside")
assert oout.getvalue() == 'Outside\nOutside2\n'
assert oerr.getvalue() == 'Err1\nErr2\n'
def test_yatr():
yatr = Yatr('foo bar')
assert yatr.name == 'foo bar'
assert yatr.order == Yatr.order
assert is_hashable(yatr)
assert not yatr.check()
assert not yatr.installed()
with assign(depd, 'command', MagicMock()):
ops = yatr.satisfy()
assert len(ops) == 1
Operation.optimize(ops)
for op in ops:
op.execute()
assert depd.command.call_count == 1
depd.command.assert_called_with('yatr foo bar')
yatr2 = Yatr.from_conf({'bar baz':
{'order': -30,
'yatrfile': '/foo/bar.yml'}})
assert yatr2.order == -30
with assign(depd, 'command', MagicMock()):
ops = yatr2.satisfy()
assert len(ops) == 1
Operation.optimize(ops)
for op in ops:
op.execute()
assert depd.command.call_count == 1
depd.command.assert_called_with('yatr -f /foo/bar.yml bar baz')
def test_assign():
from syn.base_utils import assign
class Foo(object):
lst = [1, 2, 3]
assert Foo.lst == [1, 2, 3]
with assign(Foo, 'lst', [3, 4, 5]) as lst:
assert Foo.lst == [3, 4, 5]
assert lst is Foo.lst
assert Foo.lst == [1, 2, 3]
with assign(Foo, 'lst', [3, 4, 5], lock=True):
assert Foo.lst == [3, 4, 5]
assert Foo.lst == [1, 2, 3]
assert not hasattr(Foo, 'a')
with assign(Foo, 'a', 1):
assert hasattr(Foo, 'a')
assert Foo.a == 1
assert not hasattr(Foo, 'a')
def exc():
with assign(Foo, 'a', 1):
assert Foo.a == 1
raise RuntimeError
assert_raises(RuntimeError, exc)
assert not hasattr(Foo, 'a')
def test_values():
msgs = []
class FakeLogger(object):
def warning(self, msg):
msgs.append(msg)
logger = FakeLogger()
samples = gv.TEST_SAMPLES
suppress = gv.SUPPRESS_TEST_ERRORS
try:
with setitem(os.environ, 'SYN_TEST_SAMPLES', '0'):
gv.set_values()
assert gv.TEST_SAMPLES == 0
with assign(gv, 'test_logger', logger):
gv.check_values()
assert msgs[-1] == 'TEST_SAMPLES set to value <= 0 (0) in syn.globals'
with setitem(os.environ, 'SYN_SUPPRESS_TEST_ERRORS', '0'):
gv.set_values()
assert gv.SUPPRESS_TEST_ERRORS is False
with setitem(os.environ, 'SYN_SUPPRESS_TEST_ERRORS', '1'):
gv.set_values()
assert gv.SUPPRESS_TEST_ERRORS is True
finally:
gv.set_values()
assert gv.TEST_SAMPLES == samples
assert gv.SUPPRESS_TEST_ERRORS == suppress
def forward_check(self, **kwargs):
if not self.forward_checking:
yield
else:
theory = kwargs['theory']
vars = set(theory)
dom = self.problem.domain.copy()
one_left_cons = [con for con in self.problem.constraints
if len(set(con.args) - vars) == 1]
for con in one_left_cons:
th = dict(theory)
var = (set(con.args) - vars).pop()
vals = []
for val in dom[var].lazy_enumerate(**kwargs):
th[var] = val
if not con.check(**th):
vals.append(val)
if vals:
dom[var] = Difference(dom[var], vals)
with assign(self.problem, 'domain', dom):
yield
def test_fix_functions():
from yatr import Env
class Foo(object):
pass
def fooer():
ret = Foo()
ret.hex = 'foo'
return ret
def identity(s=None, **kwargs):
return s
env = Env(macros=dict(abc='def'),
jinja_functions=dict(abc=identity))
with capture() as (out, err):
with assign(ybase, 'uuid4', fooer):
out = fix_functions("{{abc('sdf')}} {{abc}} {{abc('qwe')}}",
{'abc'}, env)
assert out == "{{abc_foo('sdf')}} {{abc}} {{abc_foo('qwe')}}"
assert resolve(out, env.macros, jenv=env.jenv) == 'sdf def qwe'
out = fix_functions("{{abc('ghi')}}", {'abc'}, env)
assert out == "{{abc_foo('ghi')}}"
assert resolve(out, env.macros, jenv=env.jenv) == 'ghi'
def iterate(self, node, **kwargs):
for k, s in enumerate(
node.siblings(following=self.following,
preceding=self.preceding,
axis=True)):
with assign(s, POSITION, k):
yield s
def test_values():
msgs = []
class FakeLogger(object):
def warning(self, msg):
msgs.append(msg)
logger = FakeLogger()
samples = gv.TEST_SAMPLES
suppress = gv.SUPPRESS_TEST_ERRORS
try:
with setitem(os.environ, 'SYN_TEST_SAMPLES', '0'):
gv.set_values()
assert gv.TEST_SAMPLES == 0
with assign(gv, 'test_logger', logger):
gv.check_values()
assert msgs[
-1] == 'TEST_SAMPLES set to value <= 0 (0) in syn.globals'
with setitem(os.environ, 'SYN_SUPPRESS_TEST_ERRORS', '0'):
gv.set_values()
assert gv.SUPPRESS_TEST_ERRORS is False
with setitem(os.environ, 'SYN_SUPPRESS_TEST_ERRORS', '1'):
gv.set_values()
assert gv.SUPPRESS_TEST_ERRORS is True
finally:
gv.set_values()
assert gv.TEST_SAMPLES == samples
assert gv.SUPPRESS_TEST_ERRORS == suppress
def forward_check(self, **kwargs):
if not self.forward_checking:
yield
else:
theory = kwargs['theory']
vars = set(theory)
dom = self.problem.domain.copy()
one_left_cons = [
con for con in self.problem.constraints
if len(set(con.args) - vars) == 1
]
for con in one_left_cons:
th = dict(theory)
var = (set(con.args) - vars).pop()
vals = []
for val in dom[var].lazy_enumerate(**kwargs):
th[var] = val
if not con.check(**th):
vals.append(val)
if vals:
dom[var] = Difference(dom[var], vals)
with assign(self.problem, 'domain', dom):
yield
def test_apt():
apt = Apt('make')
assert apt.name == 'make'
assert apt.order == Apt.order
assert is_hashable(apt)
if depd.output('which apt-get'):
if depd.output('which make'):
assert 'make' in Apt._pkgs
with assign(depd, 'command', MagicMock()):
with assign(Apt, '_pkgs', dict(make='1.0')):
assert apt.check()
assert apt.satisfy() == []
assert depd.command.call_count == 0
with assign(Apt, '_pkgs', dict()):
assert not apt.check()
ops = apt.satisfy()
assert ops == [Update(order=Apt.order),
Install('make', order=Apt.order)]
# Make sure update precedes install
assert ops[0].order == Apt.order - 1
assert ops[1].order == Apt.order
Operation.optimize(ops)
for op in ops:
op.execute()
assert depd.command.call_count == 2
depd.command.assert_any_call('apt-get update')
depd.command.assert_called_with('apt-get install -y make')
def bad_output(*args, **kwargs):
raise OSError()
with assign(depd, 'output', bad_output):
with assign(Apt, '_pkgs', dict()):
Apt._populate_pkgs()
assert Apt._pkgs == {}
if depd.output('which apt-get'):
if depd.output('which make'):
assert 'make' in Apt._pkgs
def test_elog():
from syn.base_utils import elog, this_module
import syn.base_utils.py as sp
modname = this_module().__name__
class ElogTest(Exception): pass
msgs = []
class FakeLogger(object):
def error(self, msg):
msgs.append(msg)
@classmethod
def cmeth(cls):
pass
@staticmethod
def smeth():
pass
FakeLogger.cmeth()
FakeLogger.smeth()
logger = FakeLogger()
with assign(sp, 'elogger', logger):
elog(ElogTest('msg 1'), elog, (1, 1.2, 'abc'))
assert msgs[-1] == ('***ElogTest***: "msg 1" --- '
'syn.base_utils.py.elog(1, 1.2, abc)')
elog(ElogTest('msg 2'), message, (1, 1.2, 'abc'), dict(a=2, b=3.4))
assert msgs[-1] == ('***ElogTest***: "msg 2" --- '
'syn.base_utils.py.message(1, 1.2, abc, a=2, b=3.4)')
elog(ElogTest('msg 3'), test_elog, (1, 1.2, 'abc'), dict(a=2),
pretty=False)
assert msgs[-1] == ('***ElogTest***: "msg 3" --- '
'{}.test_elog'.format(modname) +
'(args=(1, 1.2, \'abc\'), '
'kwargs={\'a\': 2})')
elog(ElogTest('msg4'), logger.error, ('abc',))
assert msgs[-1] == ('***ElogTest***: "msg4" --- '
'{}.FakeLogger.error(abc)'.format(modname))
elog(ElogTest('msg5'), FakeLogger.cmeth)
assert msgs[-1] == ('***ElogTest***: "msg5" --- '
'{}.FakeLogger.cmeth()'.format(modname))
elog(ElogTest('msg6'), FakeLogger.smeth)
assert msgs[-1] == ('***ElogTest***: "msg6" --- '
'{}.smeth()'.format(modname))
elog(ElogTest('msg7'), FakeLogger.smeth, name='FakeLogger.smeth')
assert msgs[-1] == ('***ElogTest***: "msg7" --- '
'{}.FakeLogger.smeth()'.format(modname))
elog(ElogTest('msg8'), elog, (1, 1.2, u'ab\u2013cd'))
def run_preview(self, env, **kwargs):
kwargs['preview'] = True
kwargs['verbose'] = True
kwargs['run_preview'] = True
with assign(sys, 'stdout', cStringIO()):
self.run(env, **kwargs)
ret = sys.stdout.getvalue()
return ret
def test_container_marshal_run_args():
Container
c = Container('ubuntu')
with assign(c, 'name', None):
assert c.marshal_args(RA) == ' ubuntu'
assert c.marshal_args(CC) == dict(tty = False,
image = 'ubuntu',
stdin_open = False,
host_config = {},
network_disabled = False,
detach = False)
with assign(c, 'name', None):
c = Container('debian:jessie', 'python foo.py',
tty=True, stdin_open=True, name='test',
volumes_from=['foo', 'bar'])
assert c.marshal_args(RA) == (' -t -i --volumes-from foo --volumes-from bar '
'--name test debian:jessie python foo.py')
assert_raises(ValueError, c.marshal_args, 'foo')
def test_predicates():
p = Predicate()
assert_raises(NotImplementedError, p, 1)
p = Any()
assert p(1) is True
p = Name('foo')
assert p(Node(_name='foo'))
assert not p(Node(_name='bar'))
assert not p(Node(name='foo'))
p = Name('foo', name_attr='name')
assert p(Node(name='foo'))
assert not p(Node(name='bar'))
assert not p(Node(_name='foo'))
p = Position(1)
n = Node()
with assign(n, POSITION, 0):
assert not p(n)
with assign(n, POSITION, 1):
assert p(n)
with assign(n, POSITION, 2):
assert not p(n)
p = Position(2, start_offset=1)
n = Node()
with assign(n, POSITION, 0):
assert not p(n)
with assign(n, POSITION, 1):
assert p(n)
with assign(n, POSITION, 2):
assert not p(n)
def test_main():
def invoke(cmd):
if isinstance(cmd, STR):
_main(*shlex.split(cmd))
else:
_main(*cmd)
# Version
with assign(sys, 'argv', ['', 'version']):
with capture() as (out, err):
main()
assert out.getvalue() == 'depman {}\n'.format(dver)
# Satisfy
with assign(aptd, 'command', MagicMock()):
with assign(pipd, 'command', MagicMock()):
with assign(Pip, '_pkgs', dict(lxml='', PyYAML='')):
with assign(Apt, '_pkgs', {
'libxml2-dev': '',
'libxslt1-dev': ''
}):
invoke(['satisfy', '-f', DEPS1])
assert aptd.command.call_count == 0
assert pipd.command.call_count == 0
# Validate
with assign(aptd, 'command', MagicMock()):
with assign(pipd, 'command', MagicMock()):
with assign(Pip, '_pkgs', dict(lxml='', PyYAML='')):
invoke(['validate', '-f', DEPS1])
assert aptd.command.call_count == 0
assert pipd.command.call_count == 0
# Validate the example file(s)
invoke(['validate', '-f', DEPSEX])
# Export
eout = '''# Auto-generated by depman 0.3.4
gevent<=1.0.2
numpy
openopt
six
syn>=0.0.14'''
invoke(['export', 'prod', '-f', DEPSEX, '-t', 'pip', '-o', TEST1])
with open(TEST1, 'rt') as f:
assert f.read() == eout
#Version
invoke(['version'])
def test_predicates():
p = Predicate()
assert_raises(NotImplementedError, p, 1)
p = Any()
assert p(1) is True
p = Name('foo')
assert p(Node(_name='foo'))
assert not p(Node(_name='bar'))
assert not p(Node(name='foo'))
p = Name('foo', name_attr='name')
assert p(Node(name='foo'))
assert not p(Node(name='bar'))
assert not p(Node(_name='foo'))
p = Position(1)
n = Node()
with assign(n, POSITION, 0):
assert not p(n)
with assign(n, POSITION, 1):
assert p(n)
with assign(n, POSITION, 2):
assert not p(n)
p = Position(2, start_offset=1)
n = Node()
with assign(n, POSITION, 0):
assert not p(n)
with assign(n, POSITION, 1):
assert p(n)
with assign(n, POSITION, 2):
assert not p(n)
def test_pip():
pip = Pip('six')
assert pip.order == Pip.order
assert not pip.always_upgrade
assert is_hashable(pip)
assert 'syn' in pip._pkgs
assert 'six' in pip._pkgs
assert pip.check()
with assign(pip, 'version', Ge('0')):
assert pip.check()
with assign(pip, 'version', Ge('100000000000')):
assert not pip.check()
with assign(pip, 'name', 'foobarbaz123789'):
assert not pip.check()
with assign(depd, 'command', MagicMock()):
pip.satisfy()
assert depd.command.call_count == 0
with assign(pip, 'name', 'foobarbaz123789'):
ops = pip.satisfy()
assert ops == [Install('foobarbaz123789', order=Pip.order)]
Operation.optimize(ops)
for op in ops:
op.execute()
depd.command.assert_called_with(
'pip install --upgrade foobarbaz123789')
with assign(pip, 'always_upgrade', True):
ops = pip.satisfy()
assert ops == [Install('six', order=Pip.order)]
Operation.optimize(ops)
for op in ops:
op.execute()
depd.command.assert_called_with('pip install --upgrade six')
def bad_output(*args, **kwargs):
raise OSError()
with assign(depd, 'output', bad_output):
with assign(Pip, '_pkgs', dict()):
Pip._populate_pkgs()
assert Pip._pkgs == {}
def test_main():
def invoke(cmd):
if isinstance(cmd, STR):
_main(*shlex.split(cmd))
else:
_main(*cmd)
# Version
with assign(sys, 'argv', ['', 'version']):
with capture() as (out, err):
main()
assert out.getvalue() == 'depman {}\n'.format(dver)
# Satisfy
with assign(aptd, 'command', MagicMock()):
with assign(pipd, 'command', MagicMock()):
with assign(Pip, '_pkgs', dict(lxml='', PyYAML='')):
with assign(Apt, '_pkgs', {'libxml2-dev': '',
'libxslt1-dev': ''}):
invoke(['satisfy', '-f', DEPS1])
assert aptd.command.call_count == 0
assert pipd.command.call_count == 0
# Validate
with assign(aptd, 'command', MagicMock()):
with assign(pipd, 'command', MagicMock()):
with assign(Pip, '_pkgs', dict(lxml='', PyYAML='')):
invoke(['validate', '-f', DEPS1])
assert aptd.command.call_count == 0
assert pipd.command.call_count == 0
# Validate the example file(s)
invoke(['validate', '-f', DEPSEX])
# Export
eout = '''# Auto-generated by depman 0.3.4
gevent<=1.0.2
numpy
openopt
six
syn>=0.0.14'''
invoke(['export', 'prod', '-f', DEPSEX, '-t', 'pip', '-o', TEST1])
with open(TEST1, 'rt') as f:
assert f.read() == eout
#Version
invoke(['version'])
def test_pip():
pip = Pip('six')
assert pip.order == Pip.order
assert not pip.always_upgrade
assert is_hashable(pip)
assert 'syn' in pip._pkgs
assert 'six' in pip._pkgs
assert pip.check()
with assign(pip, 'version', Ge('0')):
assert pip.check()
with assign(pip, 'version', Ge('100000000000')):
assert not pip.check()
with assign(pip, 'name', 'foobarbaz123789'):
assert not pip.check()
with assign(depd, 'command', MagicMock()):
pip.satisfy()
assert depd.command.call_count == 0
with assign(pip, 'name', 'foobarbaz123789'):
ops = pip.satisfy()
assert ops == [Install('foobarbaz123789', order=Pip.order)]
Operation.optimize(ops)
for op in ops:
op.execute()
depd.command.assert_called_with('pip install --upgrade foobarbaz123789')
with assign(pip, 'always_upgrade', True):
ops = pip.satisfy()
assert ops == [Install('six', order=Pip.order)]
Operation.optimize(ops)
for op in ops:
op.execute()
depd.command.assert_called_with('pip install --upgrade six')
def bad_output(*args, **kwargs):
raise OSError()
with assign(depd, 'output', bad_output):
with assign(Pip, '_pkgs', dict()):
Pip._populate_pkgs()
assert Pip._pkgs == {}
def validate(self):
if self._children_set:
with assign(self, '_children', []):
super(PythonNode, self).validate()
for attr in self._groups[ACO]:
val = getattr(self, attr)
if val is not None:
if isinstance(val, list):
for item in val:
if item is not None:
item.validate()
else:
val.validate()
else:
super(PythonNode, self).validate()
def validate(self):
if self._children_set:
with assign(self, '_children', []):
super(PythonNode, self).validate()
for attr in self._groups[ACO]:
val = getattr(self, attr)
if val is not None:
if isinstance(val, list):
for item in val:
if item is not None:
item.validate()
else:
val.validate()
else:
super(PythonNode, self).validate()
def test_env():
Updateable()._update_pre({})
Updateable()._update_post({})
with assign(ye, 'INITIAL_MACROS', dict(a='1', b='2')):
e = Env()
assert e.macros
assert e.contexts
assert e.default_context
assert not e.tasks
assert not e.secret_values
e1 = Env(macros=dict(a='b', b='{{a}}c', c='d{{b}}'))
e2 = Env(macros=dict(a='a', d='{{c}}e'))
e3 = Env(macros=dict(a='{{d}}'))
e1c = e1.copy()
assert_equivalent(e1, e1c)
assert_equivalent(e1.macros, e1c.macros)
e0 = deepcopy(e1)
e0.resolve_macros()
assert e0.env == dict(a='b', b='bc', c='dbc')
e1.update(e2)
e1c = deepcopy(e1)
e1.resolve_macros()
assert e1.env == dict(a='a', b='ac', c='dac', d='dace')
e2.macros['a'] = 'c'
e1c.update(e2)
e1c2 = deepcopy(e1c)
e1c.resolve_macros()
assert e1c.env == dict(a='c', b='cc', c='dcc', d='dcce')
e1c2.update(e3)
assert_raises(ValueError, e1c2.resolve_macros)
e = Env(default_task='foo')
e.update(Env())
assert e.default_task == 'foo'
e.update(Env(default_task='bar'))
assert e.default_task == 'bar'
def resolve(template, env, lenient=False, jenv=None):
if isinstance(template, dict):
return {
key: resolve(item, env, lenient, jenv)
for key, item in template.items()
}
if isinstance(template, list):
return [resolve(elem, env, lenient, jenv) for elem in template]
if isinstance(template, STR):
if '{{' in template:
if lenient:
if jenv:
with assign(jenv, 'undefined', Undefined):
return jenv.from_string(template).render(env)
return Template(template).render(env)
else:
if jenv is None:
jenv = Environment(undefined=StrictUndefined)
return jenv.from_string(template).render(env)
return template
def test_ngzwarn():
from syn.base_utils import ngzwarn, this_module
import syn.base_utils.py as sp
mod = this_module()
msgs = []
class FakeLogger(object):
def warning(self, msg):
msgs.append(msg)
logger = FakeLogger()
with assign(sp, 'test_logger', logger):
ngzwarn(1, 'FOO')
assert msgs == []
ngzwarn(0, 'Test value 1')
assert msgs[-1] == ('Test value 1 set to value <= 0 (0) in {}'
.format(mod.__name__))
ngzwarn(-1, 'Test value 2')
assert msgs[-1] == ('Test value 2 set to value <= 0 (-1) in {}'
.format(mod.__name__))
def test_ngzwarn():
from syn.base_utils import ngzwarn, this_module
import syn.base_utils.py as sp
mod = this_module()
msgs = []
class FakeLogger(object):
def warning(self, msg):
msgs.append(msg)
logger = FakeLogger()
with assign(sp, 'test_logger', logger):
ngzwarn(1, 'FOO')
assert msgs == []
ngzwarn(0, 'Test value 1')
assert msgs[-1] == ('Test value 1 set to value <= 0 (0) in {}'.format(
mod.__name__))
ngzwarn(-1, 'Test value 2')
assert msgs[-1] == ('Test value 2 set to value <= 0 (-1) in {}'.format(
mod.__name__))
def test1():
with open(os.path.join(DIR, 'test1.yml'), 'r') as f:
deps = Dependencies.from_yaml(f)
ops = []
for dep in deps.deps_from_context('all'):
ops.extend(dep.satisfy())
Operation.optimize(ops)
assert len(ops) == 6
with assign(_yatr, 'command', MagicMock()):
ops[0].execute()
assert _yatr.command.call_count == 1
_yatr.command.assert_called_with('yatr -f /foo/bar.yml init')
with assign(_apt, 'command', MagicMock()):
ops[1].execute()
assert _apt.command.call_count == 1
_apt.command.assert_called_with('apt-get update')
with assign(_apt, 'command', MagicMock()):
ops[2].execute()
assert _apt.command.call_count == 1
_apt.command.assert_called_with('apt-get install -y foo123')
with assign(_pip, 'command', MagicMock()):
ops[3].execute()
assert _pip.command.call_count == 1
_pip.command.assert_called_with('pip install --upgrade bar456')
with assign(_pip, 'command', MagicMock()):
ops[4].execute()
assert _pip.command.call_count == 1
_pip.command.assert_called_with('pip install --upgrade openopt')
with assign(_yatr, 'command', MagicMock()):
ops[5].execute()
assert _yatr.command.call_count == 1
_yatr.command.assert_called_with('yatr -f /foo/bar.yml cleanup')
def test1():
with open(os.path.join(DIR, 'test1.yml'), 'r') as f:
deps = Dependencies.from_yaml(f)
ops = []
for dep in deps.deps_from_context('all'):
ops.extend(dep.satisfy())
Operation.optimize(ops)
assert len(ops) == 6
with assign(_yatr, 'command', MagicMock()):
ops[0].execute()
assert _yatr.command.call_count == 1
_yatr.command.assert_called_with('yatr -f /foo/bar.yml init')
with assign(_apt, 'command', MagicMock()):
ops[1].execute()
assert _apt.command.call_count == 1
_apt.command.assert_called_with('apt-get update')
with assign(_apt, 'command', MagicMock()):
ops[2].execute()
assert _apt.command.call_count == 1
_apt.command.assert_called_with('apt-get install -y foo123')
with assign(_pip, 'command', MagicMock()):
ops[3].execute()
assert _pip.command.call_count == 1
_pip.command.assert_called_with('pip install --upgrade bar456')
with assign(_pip, 'command', MagicMock()):
ops[4].execute()
assert _pip.command.call_count == 1
_pip.command.assert_called_with('pip install --upgrade openopt')
with assign(_yatr, 'command', MagicMock()):
ops[5].execute()
assert _yatr.command.call_count == 1
_yatr.command.assert_called_with('yatr -f /foo/bar.yml cleanup')
def iterate(self, node, **kwargs):
parent = node.parent()
if parent is not None:
with assign(parent, POSITION, 0):
yield parent
def iterate(self, node, **kwargs):
for k, f in enumerate(node.following()):
with assign(f, POSITION, k):
yield f
def iterate(self, node, **kwargs):
for k, d in enumerate(
node.descendants(include_self=self.include_self)):
with assign(d, POSITION, k):
yield d
def test_dependencies():
def assert_listeq(A, B):
for a in A:
assert a in B
for b in B:
assert b in A
with open(DEPS1, 'rt') as f:
deps = Dependencies.from_yaml(f)
contexts = dict(dev = [Apt('libxml2-dev'),
Apt('libxslt1-dev'),
Pip('lxml')],
prod = [Pip('PyYAML')])
assert_equivalent(deps, Dependencies(contexts=contexts))
assert_listeq(deps.deps_from_context('all'),
deps.contexts.dev + deps.contexts.prod)
assert deps.deps_from_context('dev') == deps.contexts.dev
assert deps.deps_from_context('prod') == deps.contexts.prod
assert_raises(ValueError, deps.deps_from_context, 'foo')
with open(DEPS2, 'rt') as f:
deps2 = Dependencies.from_yaml(f)
contexts = dict(dev = [Apt('gcc', order=0),
Apt('make')])
assert_equivalent(deps2, Dependencies(contexts = contexts))
assert deps2.deps_from_context('all') == deps2.contexts.dev
assert deps2.deps_from_context('dev') == deps2.contexts.dev
assert_raises(ValueError, deps2.deps_from_context, 'prod')
with open(DEPS3, 'rt') as f:
deps3 = Dependencies.from_yaml(f)
contexts = dict(prod = [Pip('six'),
Pip('syn', version=Eq('0.0.7'),
always_upgrade=True)])
assert_equivalent(deps3, Dependencies(contexts=contexts))
assert deps3.deps_from_context('all') == deps3.contexts.prod
assert_raises(ValueError, deps3.deps_from_context, 'dev')
assert deps3.deps_from_context('prod') == deps3.contexts.prod
with open(DEPS4, 'rt') as f:
deps4 = Dependencies.from_yaml(f)
assert 'includes' not in deps4.contexts
assert_listeq(deps4.deps_from_context('c1'),
deps4.contexts.c1 + deps4.contexts.c2 +
deps4.contexts.c3 + deps4.contexts.c4)
assert_listeq(deps4.deps_from_context('c2'),
deps4.contexts.c2 + deps4.contexts.c3)
assert_listeq(deps4.deps_from_context('c3'), deps4.contexts.c3)
assert_listeq(deps4.deps_from_context('c4'), deps4.contexts.c4)
assert_listeq(deps4.deps_from_context('c5'), deps4.contexts.c5)
assert_raises(AssertionError, Dependencies,
contexts = dict(c1 = [Apt('make')],
c2 = [Pip('six')]),
includes = dict(c1 = ['c2', 'c3']))
assert_raises(AssertionError, Dependencies,
contexts = dict(c1 = [Apt('make')],
c2 = [Pip('six')]),
includes = dict(c3 = ['c2', 'c2']))
with open(DEPS5, 'rt') as f:
deps5 = Dependencies.from_yaml(f)
with assign(Apt, '_pkgs', dict()):
with assign(Pip, '_pkgs', dict()):
from depman.apt import Install, Update
from depman.pip import Install as PipInstall
ops = deps5.satisfy('prod', execute=False)
assert ops == [Update(order=Apt.order),
Install('a', 'b', 'c', 'd', order=Apt.order),
PipInstall('a', 'b', 'c', order=Pip.order)]
with assign(aptd, 'command', MagicMock()):
with assign(pipd, 'command', MagicMock()):
deps5.satisfy('prod')
assert aptd.command.call_count == 2
aptd.command.assert_any_call('apt-get update')
aptd.command.assert_any_call('apt-get install -y a b c d')
assert pipd.command.call_count == 1
pipd.command.assert_any_call('pip install --upgrade a b c')
with open(DEPS6, 'rt') as f:
deps6 = Dependencies.from_yaml(f)
hdr = deps6.export_header()
assert hdr == '# Auto-generated by depman {}\n'.format(dver)
out = deps6.export('all', dispatch_type('pip'), None, write=False)
eout = hdr + 'a\nb==1.2\nc<=1.2\nd>=1.2' # expected output (or export output)
assert out == eout
with open(TEST1, 'wt') as f:
deps6.export('prod', dispatch_type('pip'), f)
with open(TEST1, 'rt') as f:
assert f.read() == eout
with assign(Apt, '_pkgs', dict(a='1', b='1.3', c='1.3', f='1')):
with assign(Pip, '_pkgs', dict(a='1', b='1.3', c='1.3')):
from depman.apt import Install, Update, Remove
from depman.pip import Install as PipInstall
ops = deps6.satisfy('prod', execute=False)
assert ops == [Remove('b', 'c', order=Apt.order),
Update(order=Apt.order),
Install('b=1.2', 'c=1.2', 'd', 'e=1.3', 'f',
order=Apt.order),
PipInstall('b==1.2', 'c==1.2', 'd', order=Pip.order)]
with assign(aptd, 'command', MagicMock()):
with assign(pipd, 'command', MagicMock()):
deps6.satisfy('prod')
assert aptd.command.call_count == 3
aptd.command.assert_any_call('apt-get remove -y b c')
aptd.command.assert_any_call('apt-get update')
aptd.command.assert_any_call('apt-get install -y b=1.2 '
'c=1.2 d e=1.3 f')
assert pipd.command.call_count == 1
pipd.command.assert_any_call('pip install --upgrade b==1.2 '
'c==1.2 d')
with open(DEPS7, 'rt') as f:
deps7 = Dependencies.from_yaml(f)
with assign(Apt, '_pkgs', dict()):
with assign(Pip, '_pkgs', dict()):
from depman.apt import Install, Update
from depman.pip import Install as PipInstall
ops = deps7.satisfy('prod', execute=False)
assert ops == [PipInstall('d', order=Pip.order),
Update(order=Apt.order),
Install('b', order=Apt.order),
Update(order=Apt.order),
Install('a', order=Apt.order),
PipInstall('c', order=Pip.order)]
with assign(aptd, 'command', MagicMock()):
with assign(pipd, 'command', MagicMock()):
deps7.satisfy('prod')
assert aptd.command.call_count == 4
aptd.command.assert_any_call('apt-get update')
aptd.command.assert_any_call('apt-get install -y a')
aptd.command.assert_any_call('apt-get install -y b')
assert pipd.command.call_count == 2
pipd.command.assert_any_call('pip install --upgrade c')
pipd.command.assert_any_call('pip install --upgrade d')
with open(DEPS8, 'rt') as f:
deps8 = Dependencies.from_yaml(f)
with assign(Apt, '_pkgs', dict()):
with assign(Pip, '_pkgs', dict()):
from depman.apt import Install, Update
from depman.pip import Install as PipInstall
from depman.yatr import Task
ops = deps8.satisfy('prod', execute=False)
assert ops == [PipInstall('g', order=Pip.order),
Update(order=Apt.order),
Install('a', 'b', 'd', order=Apt.order),
Update(order=Apt.order),
Install('c', order=Apt.order),
PipInstall('e', 'f', order=Pip.order),
Task('z', order=Yatr.order)]
with assign(aptd, 'command', MagicMock()):
with assign(pipd, 'command', MagicMock()):
with assign(yatrd, 'command', MagicMock()):
deps8.satisfy('prod')
assert aptd.command.call_count == 4
aptd.command.assert_any_call('apt-get update')
aptd.command.assert_any_call('apt-get install -y a b d')
aptd.command.assert_any_call('apt-get install -y c')
assert pipd.command.call_count == 2
pipd.command.assert_any_call('pip install --upgrade e f')
pipd.command.assert_any_call('pip install --upgrade g')
assert yatrd.command.call_count == 1
yatrd.command.assert_any_call('yatr z')
with open(DEPS9, 'rt') as f:
deps9 = Dependencies.from_yaml(f)
with assign(Apt, '_pkgs', dict()):
with assign(Pip, '_pkgs', dict()):
from depman.pip import Install as PipInstall
from depman.yatr import Task
ops = deps9.satisfy('prod', execute=False)
assert ops[0:2] == [PipInstall('a', order=Pip.order),
PipInstall('b', order=Pip.order)]
others = [PipInstall('c', order=Pip.order),
PipInstall('d', order=Pip.order),
Task('z', order=Yatr.order)]
assert ops[2] in others
assert ops[3] in others
assert ops[4] in others
with open(DEPS10, 'rt') as f:
deps10 = Dependencies.from_yaml(f)
with assign(Apt, '_pkgs', dict()):
with assign(Pip, '_pkgs', dict()):
from depman.apt import Install, Update
from depman.pip import Install as PipInstall
from depman.yatr import Task
ops = deps10.satisfy('prod', execute=False)
assert ops == [Task('install-from-source', order=Yatr.order),
Update(order=Apt.order),
Install('a', 'b', 'd', order=Apt.order),
Update(order=Apt.order),
Install('c', order=Apt.order),
Task('install-from-source-2', order=Yatr.order),
PipInstall('e', 'g', order=Pip.order),
PipInstall('f', order=Pip.order),
Task('cleanup', order=Yatr.order)]
with assign(aptd, 'command', MagicMock()):
with assign(pipd, 'command', MagicMock()):
with assign(yatrd, 'command', MagicMock()):
deps10.satisfy('prod')
assert aptd.command.call_count == 4
aptd.command.assert_any_call('apt-get update')
aptd.command.assert_any_call('apt-get install -y a b d')
aptd.command.assert_any_call('apt-get install -y c')
assert pipd.command.call_count == 2
pipd.command.assert_any_call('pip install --upgrade e g')
pipd.command.assert_any_call('pip install --upgrade f')
assert yatrd.command.call_count == 3
yatrd.command.assert_any_call('yatr install-from-source')
yatrd.command.assert_any_call('yatr install-from-source-2')
yatrd.command.assert_any_call('yatr cleanup')
with open(DEPSEX, 'rt') as f:
depsex = Dependencies.from_yaml(f)
with assign(Apt, '_pkgs', dict()):
with assign(Pip, '_pkgs', dict()):
from depman.apt import Install, Update
from depman.pip import Install as PipInstall
from depman.yatr import Task
# all
ops = depsex.satisfy('all', execute=False)
_ops = [Task('install-from-source', order=Yatr.order),
Update(order=Apt.order),
Install('libxml2-dev=2.9.1+dfsg1-5+deb8u2',
'libxslt1-dev', order=Apt.order),
Task('install-from-source-2', order=Yatr.order),
PipInstall('Sphinx',
'coverage',
'gevent==1.0.2',
'lxml',
'nose',
'numpy',
'six',
'syn',
order=Pip.order),
PipInstall('openopt', order=Pip.order),
Task('-f other_tasks.yml', 'cleanup', order=Yatr.order)]
assert ops == _ops
with assign(aptd, 'command', MagicMock()):
with assign(pipd, 'command', MagicMock()):
with assign(yatrd, 'command', MagicMock()):
depsex.satisfy('all')
assert aptd.command.call_count == 2
aptd.command.assert_any_call('apt-get update')
aptd.command.assert_any_call('apt-get install -y libxml2-dev=2.9.1+dfsg1-5+deb8u2 libxslt1-dev')
assert pipd.command.call_count == 2
pipd.command.assert_any_call('pip install --upgrade Sphinx coverage gevent==1.0.2 lxml nose numpy six syn')
pipd.command.assert_any_call('pip install --upgrade openopt')
assert yatrd.command.call_count == 3
yatrd.command.assert_any_call('yatr install-from-source')
yatrd.command.assert_any_call('yatr install-from-source-2')
yatrd.command.assert_any_call('yatr -f other_tasks.yml cleanup')
# test
ops = depsex.satisfy('test', execute=False)
_ops = [PipInstall('coverage', 'nose', order=Pip.order)]
assert ops == _ops
with assign(aptd, 'command', MagicMock()):
with assign(pipd, 'command', MagicMock()):
with assign(yatrd, 'command', MagicMock()):
depsex.satisfy('test')
assert aptd.command.call_count == 0
assert pipd.command.call_count == 1
pipd.command.assert_any_call('pip install --upgrade coverage nose')
assert yatrd.command.call_count == 0
# dev
ops = depsex.satisfy('dev', execute=False)
_ops = [Task('install-from-source', order=Yatr.order),
Update(order=Apt.order),
Install('libxml2-dev=2.9.1+dfsg1-5+deb8u2',
'libxslt1-dev', order=Apt.order),
PipInstall('Sphinx', 'coverage', 'lxml', 'nose', order=Pip.order)]
assert ops == _ops
with assign(aptd, 'command', MagicMock()):
with assign(pipd, 'command', MagicMock()):
with assign(yatrd, 'command', MagicMock()):
depsex.satisfy('dev')
assert aptd.command.call_count == 2
aptd.command.assert_any_call('apt-get update')
aptd.command.assert_any_call('apt-get install -y libxml2-dev=2.9.1+dfsg1-5+deb8u2 libxslt1-dev')
assert pipd.command.call_count == 1
pipd.command.assert_any_call('pip install --upgrade Sphinx coverage lxml nose')
assert yatrd.command.call_count == 1
yatrd.command.assert_any_call('yatr install-from-source')
# prod
ops = depsex.satisfy('prod', execute=False)
_ops = [Task('install-from-source-2', order=Yatr.order),
PipInstall('gevent==1.0.2', 'numpy', 'six', 'syn', order=Pip.order),
PipInstall('openopt', order=Pip.order),
Task('-f other_tasks.yml', 'cleanup', order=Yatr.order)]
assert ops == _ops
with assign(aptd, 'command', MagicMock()):
with assign(pipd, 'command', MagicMock()):
with assign(yatrd, 'command', MagicMock()):
depsex.satisfy('prod')
assert aptd.command.call_count == 0
assert pipd.command.call_count == 2
pipd.command.assert_any_call('pip install --upgrade gevent==1.0.2 numpy six syn')
pipd.command.assert_any_call('pip install --upgrade openopt')
assert yatrd.command.call_count == 2
yatrd.command.assert_any_call('yatr install-from-source-2')
yatrd.command.assert_any_call('yatr -f other_tasks.yml cleanup')
def exc():
with assign(Foo, 'a', 1):
assert Foo.a == 1
raise RuntimeError
def iterate(self, node, **kwargs):
parent = node.parent()
if parent is not None:
with assign(parent, POSITION, 0):
yield parent
def iterate(self, node, **kwargs):
with assign(node, POSITION, 0):
yield node
def test_diffexplorer():
l1 = [1, 2, 3]
l2 = [1, 2, 4]
x = DiffExplorer(l1, l2)
assert x.display() == u'A: 1\nB: 1'
assert x.current_value == (1, 1)
x.step()
assert x.display() == u'A: 2\nB: 2'
x.down()
assert x.display() == u'A: 2\nB: 2'
x.up()
assert x.display() == u'A: 2\nB: 2'
x.step()
assert x.display() == u'A: 3\nB: 4'
assert_raises(ExplorationError, x.step)
x.step(-1)
assert x.display() == u'A: 2\nB: 2'
x.step()
assert x.display() == u'A: 1\nB: 1'
assert_raises(ExplorationError, x.step)
x.reset()
assert list(x.depth_first()) == [(l1, l2), (1, 1), (2, 2), (3, 4)]
def last_lines(si):
return si.getvalue().split('\n')[-3:-1]
l1 = [1, [2, 3], [[4]]]
l2 = [1, [2, 6], [[5]]]
r = DiffExplorer(ValueExplorer(l1), ValueExplorer(l2))
with capture() as (out, err):
r._eval('c')
assert last_lines(out) == ['A: 1', 'B: 1']
r._eval('l')
assert last_lines(out) == [
'A: [1, [2, 3], [[4]]]', 'B: [1, [2, 6], [[5]]]'
]
r._eval('n 2')
r._eval('c')
assert last_lines(out) == ['A: [[4]]', 'B: [[5]]']
r._eval('d 2')
r._eval('c')
assert last_lines(out) == ['A: 4', 'B: 5']
r._eval('u 2')
r._eval('c')
assert last_lines(out) == ['A: [[4]]', 'B: [[5]]']
r._eval('n -1')
r._eval('c')
assert last_lines(out) == ['A: [2, 3]', 'B: [2, 6]']
d1 = dict(a=1)
d2 = dict(a=2)
r = DiffExplorer(d1, d2)
with capture() as (out, err):
r._eval('c')
assert last_lines(out) == ['A: 1', 'B: 2']
r._eval('l')
assert last_lines(out) == ["A: {'a': 1}", "B: {'a': 2}"]
class Bar(object):
def __init__(self, a, b):
self.a = a
self.b = b
b1 = Bar(1, [2, 3, 'abc'])
b2 = Bar(1, [2, 3, 'adc'])
accum = []
def fake_input(prompt):
accum.append(1)
if sum(accum) <= 1:
return 'f'
return 'q'
r = find_ne(b1, b2)
with assign(repl, 'raw_input', fake_input):
r()
def test_diffexplorer():
l1 = [1, 2, 3]
l2 = [1, 2, 4]
x = DiffExplorer(l1, l2)
assert x.display() == u'A: 1\nB: 1'
assert x.current_value == (1, 1)
x.step()
assert x.display() == u'A: 2\nB: 2'
x.down()
assert x.display() == u'A: 2\nB: 2'
x.up()
assert x.display() == u'A: 2\nB: 2'
x.step()
assert x.display() == u'A: 3\nB: 4'
assert_raises(ExplorationError, x.step)
x.step(-1)
assert x.display() == u'A: 2\nB: 2'
x.step()
assert x.display() == u'A: 1\nB: 1'
assert_raises(ExplorationError, x.step)
x.reset()
assert list(x.depth_first()) == [(l1, l2), (1, 1), (2, 2), (3, 4)]
def last_lines(si):
return si.getvalue().split('\n')[-3:-1]
l1 = [1, [2, 3], [[4]]]
l2 = [1, [2, 6], [[5]]]
r = DiffExplorer(ValueExplorer(l1), ValueExplorer(l2))
with capture() as (out, err):
r._eval('c')
assert last_lines(out) == ['A: 1', 'B: 1']
r._eval('l')
assert last_lines(out) == ['A: [1, [2, 3], [[4]]]',
'B: [1, [2, 6], [[5]]]']
r._eval('n 2')
r._eval('c')
assert last_lines(out) == ['A: [[4]]', 'B: [[5]]']
r._eval('d 2')
r._eval('c')
assert last_lines(out) == ['A: 4', 'B: 5']
r._eval('u 2')
r._eval('c')
assert last_lines(out) == ['A: [[4]]', 'B: [[5]]']
r._eval('n -1')
r._eval('c')
assert last_lines(out) == ['A: [2, 3]', 'B: [2, 6]']
d1 = dict(a = 1)
d2 = dict(a = 2)
r = DiffExplorer(d1, d2)
with capture() as (out, err):
r._eval('c')
assert last_lines(out) == ['A: 1', 'B: 2']
r._eval('l')
assert last_lines(out) == ["A: {'a': 1}", "B: {'a': 2}"]
class Bar(object):
def __init__(self, a, b):
self.a = a
self.b = b
b1 = Bar(1, [2, 3, 'abc'])
b2 = Bar(1, [2, 3, 'adc'])
accum = []
def fake_input(prompt):
accum.append(1)
if sum(accum) <= 1:
return 'f'
return 'q'
r = find_ne(b1,b2)
with assign(repl, 'raw_input', fake_input):
r()
def iterate(self, node, **kwargs):
for k, c in enumerate(node.children()):
with assign(c, POSITION, k):
yield c
def __call__(self, node, **kwargs):
for k, n in enumerate(self.node(node, **kwargs)):
if self.cond(n, **kwargs) is True:
with assign(n, POSITION, k):
yield n
def test_netypes():
from syn.types.a import NEType, NotEqual, DiffersAtIndex, DiffersAtKey, \
DifferentLength, DifferentTypes, SetDifferences, KeyDifferences, \
DiffersAtAttribute
class Foo(object):
def __init__(self, a):
self.a = a
n = NEType(1, 2)
assert str(n) == repr(n)
x = n.explorer()
assert x.current_value == (1, 2)
assert n == NEType(1, 2)
assert n != NEType(1, 3)
assert n != NotEqual(1, 2)
n = NotEqual(1, 2)
assert str(n) == '1 != 2'
accum = []
def fake_explorer():
def func():
accum.append(1)
return func
assert sum(accum) == 0
with capture() as (out, err):
with assign(n, 'explorer', fake_explorer):
n()
assert sum(accum) == 1
assert out.getvalue() == '1 != 2\n'
l1 = [1, 2, 3]
l2 = [1, 4, 3]
n = DiffersAtIndex(l1, l2, 1)
assert n.explorer().current_value == (2, 4)
assert n.message() == 'Sequences differ at index 1: 2 != 4'
assert DiffersAtIndex(l1, l2, 1) == DiffersAtIndex(l1, l2, 1)
assert DiffersAtIndex(l1, l2, 1) != DiffersAtIndex(l1, l2, 2)
assert DiffersAtIndex(l1, l2, 1) != DiffersAtIndex(l1, l1, 1)
d1 = dict(a=1, b=2)
d2 = dict(a=1, b=3)
n = DiffersAtKey(d1, d2, key='b')
assert n.explorer().current_value == (2, 3)
assert n.message() == 'Mappings differ at key "b": 2 != 3'
assert DiffersAtKey(d1, d2, 'a') == DiffersAtKey(d1, d2, 'a')
assert DiffersAtKey(d1, d2, 'a') != DiffersAtKey(d1, d2, 'b')
assert DiffersAtKey(d1, d2, 'a') != DiffersAtKey(d1, d1, 'a')
l1 = [1, 2]
l2 = [1, 2, 3]
n = DifferentLength(l1, l2)
assert n.message() == 'Different lengths: 2 != 3'
l1 = [1, 2]
l2 = (1, 2, 3)
n = DifferentTypes(l1, l2)
assert n.message() == ('Different types: {} != {}'
.format(str(list), str(tuple)))
s1 = {1, 2, 3}
s2 = {2, 3, 4}
n = SetDifferences(s1, s2)
assert n.message() == 'Exclusive items: {}'.format({1, 4})
d1 = dict(a=1, b=2)
d2 = dict(b=2)
n = KeyDifferences(d1, d2)
assert n.message() == 'Exclusive keys: {}'.format({'a'})
n = KeyDifferences(d2, d1)
assert n.message() == 'Exclusive keys: {}'.format({'a'})
f1 = Foo(1)
f2 = Foo(2)
n = DiffersAtAttribute(f1, f2, 'a')
assert n.message() == 'Objects differ at attribute "a": 1 != 2'
assert n != NotEqual(1, 2)
assert n.explorer().current_value == (1, 2)
def test_run_all_tests():
from syn.base_utils import run_all_tests
var1 = [1]
var2 = [2]
var3 = [3]
var4 = [4]
def test():
var1.append(5)
def test_blah_blah():
var2.append(6)
def blank_test():
var3.append(7)
def some_other_func():
var4.append(8)
assert 'run_all_tests' in locals()
with assign(sys, 'argv', []):
with capture() as (out, err):
run_all_tests(locals(), verbose=True)
assert out.getvalue() == 'blank_test\ntest\ntest_blah_blah\n'
assert err.getvalue() == ''
assert var1 == [1, 5]
assert var2 == [2, 6]
assert var3 == [3, 7]
assert var4 == [4]
with assign(sys, 'argv',
['', '', '--include', 'test,test_blah_blah,some_other_func']):
with capture() as (out, err):
run_all_tests(locals(), verbose=True)
assert out.getvalue() == 'test\ntest_blah_blah\n'
assert err.getvalue() == ''
assert var1 == [1, 5, 5]
assert var2 == [2, 6, 6]
assert var3 == [3, 7]
assert var4 == [4]
some_other_func()
assert var4 == [4, 8]
def test_error_func():
raise TypeError('Testing exception trace printing')
with assign(sys, 'argv', []):
with capture() as (out, err):
run_all_tests(locals(), verbose=True, print_errors=True)
assert out.getvalue() == ('blank_test\ntest\ntest_blah_blah\n'
'test_error_func\n')
assert err.getvalue().split('\n')[-2] == \
'TypeError: Testing exception trace printing'
with assign(sys, 'argv', ['--print-errors']):
with capture() as (out, err):
run_all_tests(locals(), verbose=True, print_errors=False)
assert out.getvalue() == ('blank_test\ntest\ntest_blah_blah\n'
'test_error_func\n')
assert err.getvalue().split('\n')[-2] == \
'TypeError: Testing exception trace printing'
with assign(sys, 'argv', []):
with capture() as (out, err):
assert_raises(TypeError,
run_all_tests,
locals(),
verbose=True,
print_errors=False)
def iterate(self, node, **kwargs):
for k, d in enumerate(node.descendants(include_self=self.include_self)):
with assign(d, POSITION, k):
yield d
def iterate(self, node, **kwargs):
for k, p in enumerate(node.preceding()):
with assign(p, POSITION, k):
yield p
def iterate(self, node, **kwargs):
root = node.root()
with assign(root, POSITION, 0):
yield root
def test_run_all_tests():
from syn.base_utils import run_all_tests
var1 = [1]
var2 = [2]
var3 = [3]
var4 = [4]
def test():
var1.append(5)
def test_blah_blah():
var2.append(6)
def blank_test():
var3.append(7)
def some_other_func():
var4.append(8)
assert 'run_all_tests' in locals()
with assign(sys, 'argv', []):
with capture() as (out, err):
run_all_tests(locals(), verbose=True)
assert out.getvalue() == 'blank_test\ntest\ntest_blah_blah\n'
assert err.getvalue() == ''
assert var1 == [1,5]
assert var2 == [2,6]
assert var3 == [3,7]
assert var4 == [4]
with assign(sys, 'argv', ['', '', '--include',
'test,test_blah_blah,some_other_func']):
with capture() as (out, err):
run_all_tests(locals(), verbose=True)
assert out.getvalue() == 'test\ntest_blah_blah\n'
assert err.getvalue() == ''
assert var1 == [1,5,5]
assert var2 == [2,6,6]
assert var3 == [3,7]
assert var4 == [4]
some_other_func()
assert var4 == [4,8]
def test_error_func():
raise TypeError('Testing exception trace printing')
with assign(sys, 'argv', []):
with capture() as (out, err):
run_all_tests(locals(), verbose=True, print_errors=True)
assert out.getvalue() == ('blank_test\ntest\ntest_blah_blah\n'
'test_error_func\n')
assert err.getvalue().split('\n')[-2] == \
'TypeError: Testing exception trace printing'
with assign(sys, 'argv', ['--print-errors']):
with capture() as (out, err):
run_all_tests(locals(), verbose=True, print_errors=False)
assert out.getvalue() == ('blank_test\ntest\ntest_blah_blah\n'
'test_error_func\n')
assert err.getvalue().split('\n')[-2] == \
'TypeError: Testing exception trace printing'
with assign(sys, 'argv', []):
with capture() as (out, err):
assert_raises(TypeError, run_all_tests, locals(), verbose=True,
print_errors=False)
def test_repl():
from syn.base_utils import repl_command
import syn.base_utils.repl as repl
class R1(repl.REPL):
commands = dict(repl.REPL.commands)
command_help = dict(repl.REPL.command_help)
@repl_command('a', 'foo')
def foo(self):
print("foo!")
@repl_command('b', 'RuntimeError')
def rterr(self):
raise RuntimeError('error!')
def last_line(si):
return si.getvalue().split('\n')[-2]
r1 = R1('r1> ')
with capture() as (out, err):
r1._eval('a')
assert last_line(out) == 'foo!'
r1._eval('zzz')
assert last_line(out) == 'Unrecognized command: zzz'
r1._eval('b')
assert last_line(out) == 'Error in b: ***RuntimeError***: error!'
r1._eval('e "1 + 2"')
assert last_line(out) == '3'
r1._eval('h')
assert last_line(out) == ' q quit'
fi_count = []
def fake_input(prompt):
fi_count.append(1)
N = sum(fi_count)
if N <= 4:
return 'e {}'.format(N)
else:
raise EOFError
def fake_input2(prompt):
fi_count.append(1)
return 'q'
assert sum(fi_count) == 0
with assign(repl, 'raw_input', fake_input):
r1()
assert last_line(out) == '4'
assert sum(fi_count) == 5
with assign(repl, 'raw_input', fake_input2):
r1()
assert sum(fi_count) == 6
# Test overriding e in a REPL subclass
class R2(R1):
@repl_command('e', 'bar')
def bar(self, *args):
print("bar!")
r2 = R2('r2> ')
with capture() as (out, err):
r2._eval('a')
assert last_line(out) == 'foo!'
r2._eval('e "1 + 2"')
assert last_line(out) == 'bar!'
assert len(repl.REPL.commands) == 4
assert len(repl.REPL.command_help) == 4
def iterate(self, node, **kwargs):
for k, f in enumerate(node.following()):
with assign(f, POSITION, k):
yield f
def iterate(self, node, **kwargs):
for k, a in enumerate(node.ancestors(include_self=self.include_self)):
with assign(a, POSITION, k):
yield a
def __call__(self, node, **kwargs):
for k, n in enumerate(self.node(node, **kwargs)):
if self.cond(n, **kwargs) is True:
with assign(n, POSITION, k):
yield n
def iterate(self, node, **kwargs):
for k, a in enumerate(node.ancestors(include_self=self.include_self)):
with assign(a, POSITION, k):
yield a
def iterate(self, node, **kwargs):
for k, c in enumerate(node.children()):
with assign(c, POSITION, k):
yield c
def iterate(self, node, **kwargs):
for k, p in enumerate(node.preceding()):
with assign(p, POSITION, k):
yield p
def test_netypes():
from syn.types.a import NEType, NotEqual, DiffersAtIndex, DiffersAtKey, \
DifferentLength, DifferentTypes, SetDifferences, KeyDifferences, \
DiffersAtAttribute
class Foo(object):
def __init__(self, a):
self.a = a
n = NEType(1, 2)
assert str(n) == repr(n)
x = n.explorer()
assert x.current_value == (1, 2)
assert n == NEType(1, 2)
assert n != NEType(1, 3)
assert n != NotEqual(1, 2)
n = NotEqual(1, 2)
assert str(n) == '1 != 2'
accum = []
def fake_explorer():
def func():
accum.append(1)
return func
assert sum(accum) == 0
with capture() as (out, err):
with assign(n, 'explorer', fake_explorer):
n()
assert sum(accum) == 1
assert out.getvalue() == '1 != 2\n'
l1 = [1, 2, 3]
l2 = [1, 4, 3]
n = DiffersAtIndex(l1, l2, 1)
assert n.explorer().current_value == (2, 4)
assert n.message() == 'Sequences differ at index 1: 2 != 4'
assert DiffersAtIndex(l1, l2, 1) == DiffersAtIndex(l1, l2, 1)
assert DiffersAtIndex(l1, l2, 1) != DiffersAtIndex(l1, l2, 2)
assert DiffersAtIndex(l1, l2, 1) != DiffersAtIndex(l1, l1, 1)
d1 = dict(a=1, b=2)
d2 = dict(a=1, b=3)
n = DiffersAtKey(d1, d2, key='b')
assert n.explorer().current_value == (2, 3)
assert n.message() == 'Mappings differ at key "b": 2 != 3'
assert DiffersAtKey(d1, d2, 'a') == DiffersAtKey(d1, d2, 'a')
assert DiffersAtKey(d1, d2, 'a') != DiffersAtKey(d1, d2, 'b')
assert DiffersAtKey(d1, d2, 'a') != DiffersAtKey(d1, d1, 'a')
l1 = [1, 2]
l2 = [1, 2, 3]
n = DifferentLength(l1, l2)
assert n.message() == 'Different lengths: 2 != 3'
l1 = [1, 2]
l2 = (1, 2, 3)
n = DifferentTypes(l1, l2)
assert n.message() == ('Different types: {} != {}'.format(
str(list), str(tuple)))
s1 = {1, 2, 3}
s2 = {2, 3, 4}
n = SetDifferences(s1, s2)
assert n.message() == 'Exclusive items: {}'.format({1, 4})
d1 = dict(a=1, b=2)
d2 = dict(b=2)
n = KeyDifferences(d1, d2)
assert n.message() == 'Exclusive keys: {}'.format({'a'})
n = KeyDifferences(d2, d1)
assert n.message() == 'Exclusive keys: {}'.format({'a'})
f1 = Foo(1)
f2 = Foo(2)
n = DiffersAtAttribute(f1, f2, 'a')
assert n.message() == 'Objects differ at attribute "a": 1 != 2'
assert n != NotEqual(1, 2)
assert n.explorer().current_value == (1, 2)
def test_repl():
from syn.base_utils import repl_command
import syn.base_utils.repl as repl
class R1(repl.REPL):
commands = dict(repl.REPL.commands)
command_help = dict(repl.REPL.command_help)
@repl_command('a', 'foo')
def foo(self):
print("foo!")
@repl_command('b', 'RuntimeError')
def rterr(self):
raise RuntimeError('error!')
def last_line(si):
return si.getvalue().split('\n')[-2]
r1 = R1('r1> ')
with capture() as (out, err):
r1._eval('a')
assert last_line(out) == 'foo!'
r1._eval('zzz')
assert last_line(out) == 'Unrecognized command: zzz'
r1._eval('b')
assert last_line(out) == 'Error in b: ***RuntimeError***: error!'
r1._eval('e "1 + 2"')
assert last_line(out) == '3'
r1._eval('h')
assert last_line(out) == ' q quit'
fi_count = []
def fake_input(prompt):
fi_count.append(1)
N = sum(fi_count)
if N <= 4:
return 'e {}'.format(N)
else:
raise EOFError
def fake_input2(prompt):
fi_count.append(1)
return 'q'
assert sum(fi_count) == 0
with assign(repl, 'raw_input', fake_input):
r1()
assert last_line(out) == '4'
assert sum(fi_count) == 5
with assign(repl, 'raw_input', fake_input2):
r1()
assert sum(fi_count) == 6
# Test overriding e in a REPL subclass
class R2(R1):
@repl_command('e', 'bar')
def bar(self, *args):
print("bar!")
r2 = R2('r2> ')
with capture() as (out, err):
r2._eval('a')
assert last_line(out) == 'foo!'
r2._eval('e "1 + 2"')
assert last_line(out) == 'bar!'
assert len(repl.REPL.commands) == 4
assert len(repl.REPL.command_help) == 4
def test_bash_completions():
settings = DEFAULT_SETTINGS
with chdir(DIR):
out = find_bash_completions(['--cache-dir', '/app', 'print'], 1)
assert out == []
out = find_bash_completions(['-f', '/app', 'print'], 1)
assert out == []
out = find_bash_completions(['--yatrfile', '/app', 'print'], 1)
assert out == []
out = find_bash_completions(['-'], 0)
assert out == OPTION_STRINGS
out = find_bash_completions(['p'], 0)
assert out == ['print']
out = find_bash_completions(['xyz'], 0)
assert out == []
out = find_bash_completions(['-m', 'a'], 1)
assert out == ['a']
out = find_bash_completions(['--macro', 'a'], 1)
assert out == ['a']
out = find_bash_completions(['-m', 'a='], 1)
assert out == []
out = find_bash_completions(['-s', 's'], 1)
assert out == ['silent']
out = find_bash_completions(['--setting', 's'], 1)
assert out == ['silent']
out = find_bash_completions(['-s', 'silent='], 1)
assert out == []
out = find_bash_completions(['--dump-path', 'p'], 1)
assert out == ['print']
out = find_bash_completions(['print', 'xyz'], 1)
assert out == []
out = find_bash_completions(['-i', '/app'], 1)
assert out == []
out = find_bash_completions(['-o', '/app'], 1)
assert out == []
out = find_bash_completions([], 0)
assert out == ['print']
out = find_bash_completions(['-m'], 1)
assert out == ['a', 'b', 'c']
out = find_bash_completions(['--macro'], 1)
assert out == ['a', 'b', 'c']
out = find_bash_completions(['-s'], 1)
assert out == settings
out = find_bash_completions(['--setting'], 1)
assert out == settings
out = find_bash_completions(['-m', 'a=xyz'], 2)
assert out == ['print']
out = find_bash_completions(['-m', 'a=xyz', 'print'], 3)
assert out == []
out = find_bash_completions(['-i'], 1)
assert out == []
out = find_bash_completions(['-o'], 1)
assert out == []
with capture() as (out, err):
dump_bash_completions(['-m'], 1)
assert out.getvalue() == 'a b c\n'
with capture() as (out, err):
_main('--dump-bash-completions', '1', '--macro')
assert out.getvalue() == 'a b c\n'
with tempdir() as d:
with chdir(d):
out = find_bash_completions(['-'], 0)
assert out == OPTION_STRINGS
out = find_bash_completions([], 0)
assert out == []
out = find_bash_completions(['-m'], 1)
assert out == []
out = find_bash_completions(['-s'], 1)
assert out == settings
yfpath = os.path.join(DIR, 'yatrfile.yml')
out = find_bash_completions(['-f', yfpath], 2)
assert out == ['print']
out = find_bash_completions(['--yatrfile', yfpath], 2)
assert out == ['print']
out = find_bash_completions(['-f', yfpath, '-s'], 3)
assert out == settings
yfpath = os.path.join(DIR, 'yatrfile.yaml')
out = find_bash_completions(['-f', yfpath], 2)
assert out == []
yfpath = os.path.join(d, 'yatrfile.yml')
shutil.copyfile(os.path.join(DIR, 'test2.yml'), yfpath)
out = find_bash_completions([], 0)
assert out == ['bad', 'good']
with tempdir() as d2:
cd = os.path.join(d2, 'foo')
out = find_bash_completions(['--cache-dir', cd], 2)
assert out == ['bad', 'good']
with open(yfpath, 'r') as f:
data = f.read()
out = data.replace('bad', 'dad')
with open(yfpath, 'w') as f:
f.write(out)
out = find_bash_completions(['--cache-dir', cd], 2)
assert out == ['dad', 'good']
spath = os.path.join(os.path.abspath(os.path.dirname(ybase.__file__)),
'scripts/completion/yatr')
dpath = '/etc/bash_completion.d/yatr'
with assign(shutil, 'copyfile', MagicMock()):
with capture() as (out, err):
_main('--install-bash-completions')
assert out.getvalue() == BASH_COMPLETION_MESSAGE + '\n'
assert shutil.copyfile.call_count == 1
shutil.copyfile.assert_any_call(spath, dpath)
def test_elog():
from syn.base_utils import elog, this_module
import syn.base_utils.py as sp
modname = this_module().__name__
class ElogTest(Exception):
pass
msgs = []
class FakeLogger(object):
def error(self, msg):
msgs.append(msg)
@classmethod
def cmeth(cls):
pass
@staticmethod
def smeth():
pass
FakeLogger.cmeth()
FakeLogger.smeth()
logger = FakeLogger()
with assign(sp, 'elogger', logger):
elog(ElogTest('msg 1'), elog, (1, 1.2, 'abc'))
assert msgs[-1] == ('***ElogTest***: "msg 1" --- '
'syn.base_utils.py.elog(1, 1.2, abc)')
elog(ElogTest('msg 2'), message, (1, 1.2, 'abc'), dict(a=2, b=3.4))
assert msgs[-1] == (
'***ElogTest***: "msg 2" --- '
'syn.base_utils.py.message(1, 1.2, abc, a=2, b=3.4)')
elog(ElogTest('msg 3'),
test_elog, (1, 1.2, 'abc'),
dict(a=2),
pretty=False)
assert msgs[-1] == ('***ElogTest***: "msg 3" --- '
'{}.test_elog'.format(modname) +
'(args=(1, 1.2, \'abc\'), '
'kwargs={\'a\': 2})')
elog(ElogTest('msg4'), logger.error, ('abc', ))
assert msgs[-1] == ('***ElogTest***: "msg4" --- '
'{}.FakeLogger.error(abc)'.format(modname))
elog(ElogTest('msg5'), FakeLogger.cmeth)
assert msgs[-1] == ('***ElogTest***: "msg5" --- '
'{}.FakeLogger.cmeth()'.format(modname))
elog(ElogTest('msg6'), FakeLogger.smeth)
assert msgs[-1] == ('***ElogTest***: "msg6" --- '
'{}.smeth()'.format(modname))
elog(ElogTest('msg7'), FakeLogger.smeth, name='FakeLogger.smeth')
assert msgs[-1] == ('***ElogTest***: "msg7" --- '
'{}.FakeLogger.smeth()'.format(modname))
elog(ElogTest('msg8'), elog, (1, 1.2, u'ab\u2013cd'))
def iterate(self, node, **kwargs):
with assign(node, POSITION, 0):
yield node
def iterate(self, node, **kwargs):
root = node.root()
with assign(root, POSITION, 0):
yield root
def iterate(self, node, **kwargs):
for k, s in enumerate(node.siblings(following=self.following,
preceding=self.preceding,
axis=True)):
with assign(s, POSITION, k):
yield s
