def test_dynamic_scope_creation():
"""Test handling bad arguments when creating dnamic scope.
"""
owner = object()
locs = sortedmap()
globs = {}
builtins = {}
change = {}
tracer = object()
dynamicscope = DynamicScope(owner, locs, globs, builtins, change, tracer)
for referrent, obj in zip(
gc.get_referents(dynamicscope),
[owner, change, tracer, locs, globs, builtins, None, None]):
assert referrent is obj
with pytest.raises(TypeError) as excinfo:
DynamicScope(owner, None, globs, builtins)
assert 'mapping' in excinfo.exconly()
with pytest.raises(TypeError) as excinfo:
DynamicScope(owner, locs, None, builtins)
assert 'dict' in excinfo.exconly()
with pytest.raises(TypeError) as excinfo:
DynamicScope(owner, locs, globs, None)
assert 'dict' in excinfo.exconly()
del dynamicscope
gc.collect()
def __call__(self, owner, name):
""" Evaluate and return the expression value.
"""
func = self.func
f_globals = func.__globals__
f_builtins = f_globals['__builtins__']
f_locals = self.get_locals(owner)
tr = TraitsTracer(owner, name)
scope = DynamicScope(owner, f_locals, f_globals, f_builtins, None, tr)
return call_func(func, (tr, ), {}, scope)
def test_dynamicscope_del(dynamicscope):
"""Test the del method.
"""
dynamicscope, args = dynamicscope
del dynamicscope['e']
assert 'e' not in dynamicscope
with pytest.raises(KeyError):
del dynamicscope['z']
dynamicscope = DynamicScope(*args)
# Test the absence of f_writes
with pytest.raises(KeyError):
del dynamicscope['z']
with pytest.raises(TypeError) as excinfo:
del dynamicscope[1]
assert 'str' in excinfo.exconly()
def dynamicscope():
"""Dynamic used for testing.
"""
class NonDataDescriptor(object):
def __init__(self, should_raise=False):
self.should_raise = should_raise
def __get__(self, instance, objtype=None):
if not self.should_raise:
return instance
else:
raise KeyError()
class ReadOnlyDescriptor(object):
def __get__(self, instance, objtype=None):
return 1
def __set__(self, instance, objtype=None):
raise AttributeError
class WriteOnlyDescriptor(object):
def __set__(self, instance, value, objtype=None):
instance.value = 1
class Owner(object):
def __init__(self):
self._parent = None
self.attribute1 = 1
self._prop2 = 0
owner = NonDataDescriptor()
prop1 = ReadOnlyDescriptor()
@property
def prop2(self):
return self._prop2
@prop2.setter
def prop2(self, value):
self._prop2 = value
@property
def key_raise(self):
raise KeyError()
non_data_key_raise = NonDataDescriptor(True)
write_only = WriteOnlyDescriptor()
class TopOwner(Owner):
@property
def top(self):
return self._top
@top.setter
def top(self, value):
self._top = 1
class Tracer(object):
"""Tracer for testing.
"""
def __init__(self):
self.traced = []
def dynamic_load(self, owner, name, value):
self.traced.append((owner, name, value))
owner = Owner()
owner.attribute1 = 2
owner._parent = TopOwner()
owner._parent.attribute2 = 1
locs = sortedmap()
locs['a'] = 1
globs = {'b': 2}
builtins = {'c': 3}
change = {'d': 4}
tracer = Tracer()
dynamicscope = DynamicScope(owner, locs, globs, builtins, change, tracer)
dynamicscope['e'] = 5 # Add an entry in the f_writes
return dynamicscope, (owner, locs, globs, builtins, change, tracer)