def getattr_not_called_on_method(self):
getattr_access = []
method_access = []
class FooProxy(object):
def method(self, proxied, name, get_result, *args, **kwargs):
method_access.append(name)
return get_result(proxied, *args, **kwargs)
def getattr(self, proxied, name):
getattr_access.append(name)
return getattr(proxied, name)
FooProxy = as_proxy(FooProxy)
class Foo(object):
spam = 1
def __add__(self, other):
return None
p = FooProxy(Foo())
p.spam
p + p
Assert(method_access) == ['__add__']
Assert(getattr_access) == ['spam']
def proper_wrapping(self):
class FooProxy(object):
"""A little bit of documentation."""
proxy_cls = as_proxy(FooProxy)
Assert(proxy_cls.__name__) == FooProxy.__name__
Assert(proxy_cls.__module__) == FooProxy.__module__
Assert(proxy_cls.__doc__) == FooProxy.__doc__
def special_method_handling(self):
def simple_method_handler(
self, proxied, name, get_result, *args, **kwargs
):
method_calls.append((name, args, kwargs))
return missing
def advanced_method_handler(
self, proxied, name, get_result, *args, **kwargs
):
method_calls.append((name, args, kwargs))
return get_result(proxied, *args, **kwargs)
for handler in [simple_method_handler, advanced_method_handler]:
class FooProxy(object):
method = handler
FooProxy = as_proxy(FooProxy)
method_calls = []
proxy = FooProxy(1)
Assert(proxy + 1) == 2
Assert(proxy - 1) == 0
Assert(proxy * 1) == 1
Assert(proxy / 1) == 1
Assert(proxy < 1) == False
Assert(method_calls) == [
('__add__', (1, ), {}),
('__sub__', (1, ), {}),
('__mul__', (1, ), {}),
('__div__', (1, ), {}),
('__lt__', (1, ), {})
]
def getattr_not_called_on_method(self):
getattr_access = []
method_access = []
class FooProxy(object):
def method(self, proxied, name, get_result, *args, **kwargs):
method_access.append(name)
return get_result(proxied, *args, **kwargs)
def getattr(self, proxied, name):
getattr_access.append(name)
return getattr(proxied, name)
FooProxy = as_proxy(FooProxy)
class Foo(object):
spam = 1
def __add__(self, other):
return None
p = FooProxy(Foo())
p.spam
p + p
Assert(method_access) == ['__add__']
Assert(getattr_access) == ['spam']
def special_method_handling(self):
def simple_method_handler(self, proxied, name, get_result, *args,
**kwargs):
method_calls.append((name, args, kwargs))
return missing
def advanced_method_handler(self, proxied, name, get_result, *args,
**kwargs):
method_calls.append((name, args, kwargs))
return get_result(proxied, *args, **kwargs)
for handler in [simple_method_handler, advanced_method_handler]:
class FooProxy(object):
method = handler
FooProxy = as_proxy(FooProxy)
method_calls = []
proxy = FooProxy(1)
Assert(proxy + 1) == 2
Assert(proxy - 1) == 0
Assert(proxy * 1) == 1
Assert(proxy / 1) == 1
Assert(proxy < 1) == False
Assert(method_calls) == [('__add__', (1, ), {}),
('__sub__', (1, ), {}),
('__mul__', (1, ), {}),
('__div__', (1, ), {}),
('__lt__', (1, ), {})]
def setting_repr(self):
class FooProxy(object):
def repr(self, proxied):
return 'FooProxy(%s)' % repr(proxied)
FooProxy = as_proxy(FooProxy)
p = FooProxy(1)
Assert(repr(p)) == 'FooProxy(1)'
def proper_wrapping(self):
class FooProxy(object):
"""A little bit of documentation."""
proxy_cls = as_proxy(FooProxy)
Assert(proxy_cls.__name__) == FooProxy.__name__
Assert(proxy_cls.__module__) == FooProxy.__module__
Assert(proxy_cls.__doc__) == FooProxy.__doc__
def setting_repr(self):
class FooProxy(object):
def repr(self, proxied):
return 'FooProxy(%s)' % repr(proxied)
FooProxy = as_proxy(FooProxy)
p = FooProxy(1)
Assert(repr(p)) == 'FooProxy(1)'
def getitem_based_iteration(self):
class Foo(object):
def __getitem__(self, key):
if key >= 3:
raise IndexError(key)
return key
proxy_cls = as_proxy(type('FooProxy', (object, ), {}))
proxy = proxy_cls(Foo())
Assert(list(proxy)) == [0, 1, 2]
def getitem_based_iteration(self):
class Foo(object):
def __getitem__(self, key):
if key >= 3:
raise IndexError(key)
return key
proxy_cls = as_proxy(type('FooProxy', (object, ), {}))
proxy = proxy_cls(Foo())
Assert(list(proxy)) == [0, 1, 2]
def default_attribute_handling(self):
proxy_cls = as_proxy(type('FooProxy', (object, ), {}))
class Foo(object):
a = 1
proxy = proxy_cls(Foo())
Assert(proxy.a) == 1
proxy.a = 2
Assert(proxy.a) == 2
def default_attribute_handling(self):
proxy_cls = as_proxy(type('FooProxy', (object, ), {}))
class Foo(object):
a = 1
proxy = proxy_cls(Foo())
Assert(proxy.a) == 1
proxy.a = 2
Assert(proxy.a) == 2
def dir(self):
class Foo(object):
bar = None
def spam(self):
pass
def eggs(self):
pass
proxy_cls = as_proxy(type('FooProxy', (object, ), {}))
Assert(dir(Foo)) == dir(proxy_cls(Foo))
def nonzero_via_len(self):
class Foo(object):
def __len__(self):
return 0
class Bar(object):
def __len__(self):
return 1
proxy_cls = as_proxy(type('FooProxy', (object, ), {}))
assert not proxy_cls(Foo())
assert proxy_cls(Bar())
def nonzero_via_len(self):
class Foo(object):
def __len__(self):
return 0
class Bar(object):
def __len__(self):
return 1
proxy_cls = as_proxy(type('FooProxy', (object, ), {}))
assert not proxy_cls(Foo())
assert proxy_cls(Bar())
def dir(self):
class Foo(object):
bar = None
def spam(self):
pass
def eggs(self):
pass
proxy_cls = as_proxy(type('FooProxy', (object, ), {}))
Assert(dir(Foo)) == dir(proxy_cls(Foo))
def delslice(self):
class Foo(object):
def __init__(self):
self.sequence = [0, 1, 2]
def __eq__(self, other):
if isinstance(other, list):
return self.sequence == other
return self.sequence == other.sequence
def __ne__(self, other):
return self.sequence != other.sequence
__hash__ = None
def __len__(self):
return len(self.sequence)
def __repr__(self):
return repr(self.sequence)
class Bar(Foo):
def __delitem__(self, key):
del self.sequence[key]
class Baz(Foo):
def __delslice__(self, i, j):
del self.sequence[i:j]
proxy_cls = as_proxy(type('FooProxy', (object, ), {}))
make_proxies = lambda: (proxy_cls(Bar()), proxy_cls(Baz()))
a, b = make_proxies()
del a[:]
del b[:]
Assert(a) == b == []
a, b = make_proxies()
del a[1:]
del b[1:]
Assert(a) == b == [0]
a, b = make_proxies()
del a[1:-1]
del b[1:-1]
Assert(a) == b == [0, 2]
a, b = make_proxies()
del a[:-1]
del b[:-1]
Assert(a) == b == [2]
def delslice(self):
class Foo(object):
def __init__(self):
self.sequence = [0, 1, 2]
def __eq__(self, other):
if isinstance(other, list):
return self.sequence == other
return self.sequence == other.sequence
def __ne__(self, other):
return self.sequence != other.sequence
__hash__ = None
def __len__(self):
return len(self.sequence)
def __repr__(self):
return repr(self.sequence)
class Bar(Foo):
def __delitem__(self, key):
del self.sequence[key]
class Baz(Foo):
def __delslice__(self, i, j):
del self.sequence[i:j]
proxy_cls = as_proxy(type('FooProxy', (object, ), {}))
make_proxies = lambda: (proxy_cls(Bar()), proxy_cls(Baz()))
a, b = make_proxies()
del a[:]
del b[:]
Assert(a) == b == []
a, b = make_proxies()
del a[1:]
del b[1:]
Assert(a) == b == [0]
a, b = make_proxies()
del a[1:-1]
del b[1:-1]
Assert(a) == b == [0, 2]
a, b = make_proxies()
del a[:-1]
del b[:-1]
Assert(a) == b == [2]
def setslice(self):
class Foo(object):
def __init__(self):
self.sequence = [0, 1, 2]
def __eq__(self, other):
if isinstance(other, list):
return self.sequence == other
return self.sequence == other.sequence
def __ne__(self, other):
return self.sequence != other.sequence
__hash__ = None
def __len__(self):
return len(self.sequence)
def __repr__(self):
return repr(self.sequence)
class Bar(Foo):
def __setitem__(self, key, value):
self.sequence[key] = value
class Baz(Foo):
def __setslice__(self, i, j, value):
self.sequence[i:j] = value
proxy_cls = as_proxy(type('FooProxy', (object, ), {}))
make_proxies = lambda: (proxy_cls(Bar()), proxy_cls(Baz()))
a, b = make_proxies()
a[:] = b[:] = 'abc'
Assert(a) == b == ['a', 'b', 'c']
a, b = make_proxies()
a[1:] = b[1:] = 'bc'
Assert(a) == b == [0, 'b', 'c']
a, b = make_proxies()
a[1:-1] = b[1:-1] = ['b']
Assert(a) == b == [0, 'b', 2]
a, b = make_proxies()
a[:-1] = b[:-1] = ['a', 'b']
Assert(a) == b == ['a', 'b', 2]
def setslice(self):
class Foo(object):
def __init__(self):
self.sequence = [0, 1, 2]
def __eq__(self, other):
if isinstance(other, list):
return self.sequence == other
return self.sequence == other.sequence
def __ne__(self, other):
return self.sequence != other.sequence
__hash__ = None
def __len__(self):
return len(self.sequence)
def __repr__(self):
return repr(self.sequence)
class Bar(Foo):
def __setitem__(self, key, value):
self.sequence[key] = value
class Baz(Foo):
def __setslice__(self, i, j, value):
self.sequence[i:j] = value
proxy_cls = as_proxy(type('FooProxy', (object, ), {}))
make_proxies = lambda: (proxy_cls(Bar()), proxy_cls(Baz()))
a, b = make_proxies()
a[:] = b[:] = 'abc'
Assert(a) == b == ['a', 'b', 'c']
a, b = make_proxies()
a[1:] = b[1:] = 'bc'
Assert(a) == b == [0, 'b', 'c']
a, b = make_proxies()
a[1:-1] = b[1:-1] = ['b']
Assert(a) == b == [0, 'b', 2]
a, b = make_proxies()
a[:-1] = b[:-1] = ['a', 'b']
Assert(a) == b == ['a', 'b', 2]
def forcing(self):
func = lambda: 1
class FooProxy(object):
def method(self, proxied, name, get_result, *args, **kwargs):
return get_result(proxied(), *args, **kwargs)
def force(self, proxied):
return proxied()
FooProxy = as_proxy(FooProxy)
proxy = FooProxy(func)
Assert(proxy + proxy) == 2
a = FooProxy(lambda: 1)
b = FooProxy(lambda: 2)
Assert(a - b) == -1
Assert(b - a) == 1
def reversed(self):
class Foo(object):
def __getitem__(self, key):
if key >= 3:
raise IndexError(key)
return key
def __len__(self):
return 3
class Bar(object):
def __reversed__(self):
yield 2
yield 1
yield 0
proxy_cls = as_proxy(type('FooProxy', (object, ), {}))
Assert(list(reversed(proxy_cls(Foo())))) == [2, 1, 0]
Assert(list(reversed(proxy_cls(Bar())))) == [2, 1, 0]
def forcing(self):
func = lambda: 1
class FooProxy(object):
def method(self, proxied, name, get_result, *args, **kwargs):
return get_result(proxied(), *args, **kwargs)
def force(self, proxied):
return proxied()
FooProxy = as_proxy(FooProxy)
proxy = FooProxy(func)
Assert(proxy + proxy) == 2
a = FooProxy(lambda: 1)
b = FooProxy(lambda: 2)
Assert(a - b) == -1
Assert(b - a) == 1
def reversed(self):
class Foo(object):
def __getitem__(self, key):
if key >= 3:
raise IndexError(key)
return key
def __len__(self):
return 3
class Bar(object):
def __reversed__(self):
yield 2
yield 1
yield 0
proxy_cls = as_proxy(type('FooProxy', (object, ), {}))
Assert(list(reversed(proxy_cls(Foo())))) == [2, 1, 0]
Assert(list(reversed(proxy_cls(Bar())))) == [2, 1, 0]
def contains(self):
class Foo(object):
def __getitem__(self, key):
if key >= 3:
raise IndexError(key)
return key
class Bar(object):
def __iter__(self):
yield 0
yield 1
yield 2
class Baz(object):
def __contains__(self, other):
return other in (0, 1, 2)
proxy_cls = as_proxy(type('FooProxy', (object, ), {}))
for cls in (Foo, Bar, Baz):
for i in xrange(3):
assert i in proxy_cls(cls())
def contains(self):
class Foo(object):
def __getitem__(self, key):
if key >= 3:
raise IndexError(key)
return key
class Bar(object):
def __iter__(self):
yield 0
yield 1
yield 2
class Baz(object):
def __contains__(self, other):
return other in (0, 1, 2)
proxy_cls = as_proxy(type('FooProxy', (object, ), {}))
for cls in (Foo, Bar, Baz):
for i in xrange(3):
assert i in proxy_cls(cls())
def getslice(self):
class Foo(object):
def __getitem__(self, key):
return [0, 1, 2][key]
def __len__(self):
return 3
class Bar(object):
def __getslice__(self, i, j):
return [0, 1, 2][i:j]
def __len__(self):
return 3
proxy_cls = as_proxy(type('FooProxy', (object, ), {}))
a = proxy_cls(Foo())
b = proxy_cls(Bar())
Assert(a[:]) == b[:] == [0, 1, 2]
Assert(a[1:]) == b[1:] == [1, 2]
Assert(a[1:-1]) == b[1:-1] == [2]
Assert(a[:-1]) == b[:-1] == [0, 1]
def getslice(self):
class Foo(object):
def __getitem__(self, key):
return [0, 1, 2][key]
def __len__(self):
return 3
class Bar(object):
def __getslice__(self, i, j):
return [0, 1, 2][i:j]
def __len__(self):
return 3
proxy_cls = as_proxy(type('FooProxy', (object, ), {}))
a = proxy_cls(Foo())
b = proxy_cls(Bar())
Assert(a[:]) == b[:] == [0, 1, 2]
Assert(a[1:]) == b[1:] == [1, 2]
Assert(a[1:-1]) == b[1:-1] == [2]
Assert(a[:-1]) == b[:-1] == [0, 1]
def attribute_handling(self):
getattr_access = []
setattr_access = []
class FooProxy(object):
def getattr(self, proxied, name):
getattr_access.append(name)
return getattr(proxied, name)
def setattr(self, proxied, name, obj):
setattr_access.append((name, obj))
return setattr(proxied, name, obj)
FooProxy = as_proxy(FooProxy)
class Foo(object):
a = 1
proxy = FooProxy(Foo())
Assert(proxy.a) == 1
proxy.a = 2
Assert(getattr_access) == ['a']
Assert(setattr_access) == [('a', 2)]
def attribute_handling(self):
getattr_access = []
setattr_access = []
class FooProxy(object):
def getattr(self, proxied, name):
getattr_access.append(name)
return getattr(proxied, name)
def setattr(self, proxied, name, obj):
setattr_access.append((name, obj))
return setattr(proxied, name, obj)
FooProxy = as_proxy(FooProxy)
class Foo(object):
a = 1
proxy = FooProxy(Foo())
Assert(proxy.a) == 1
proxy.a = 2
Assert(getattr_access) == ['a']
Assert(setattr_access) == [('a', 2)]
def default_special_method_handling(self):
proxy_cls = as_proxy(type('FooProxy', (object, ), {}))
proxy = proxy_cls(1)
Assert(proxy + 1) == 2
def test_get_wrapped():
proxy_cls = as_proxy(type('FooProxy', (object, ), {}))
wrapped = 1
Assert(get_wrapped(proxy_cls(wrapped))).is_(wrapped)
def default_repr(self):
proxy_cls = as_proxy(type('FooProxy', (object, ), {}))
Assert(repr(proxy_cls(1))) == '1'
def default_special_method_handling(self):
proxy_cls = as_proxy(type('FooProxy', (object, ), {}))
proxy = proxy_cls(1)
Assert(proxy + 1) == 2
def default_repr(self):
proxy_cls = as_proxy(type('FooProxy', (object, ), {}))
Assert(repr(proxy_cls(1))) == '1'
def test_get_wrapped():
proxy_cls = as_proxy(type('FooProxy', (object, ), {}))
wrapped = 1
Assert(get_wrapped(proxy_cls(wrapped))).is_(wrapped)
