from __future__ import print_function import unittest import imp import operator import sys import pytest is_pypy = '__pypy__' in sys.builtin_module_names import wrapt import six OBJECTS_CODE = """ class TargetBaseClass(object): "documentation" class Target(TargetBaseClass): "documentation" def target(): "documentation" pass """ objects = imp.new_module('objects') six.exec_(OBJECTS_CODE, objects.__dict__, objects.__dict__) class TestAttributeAccess(unittest.TestCase): def test_attributes(self): def function1(*args, **kwargs): return args, kwargs function2 = wrapt.ObjectProxy(function1) self.assertEqual(function2.__wrapped__, function1) def test_get_wrapped(self): def function1(*args, **kwargs): return args, kwargs function2 = wrapt.ObjectProxy(function1) self.assertEqual(function2.__wrapped__, function1) function3 = wrapt.ObjectProxy(function2) self.assertEqual(function3.__wrapped__, function1) def test_set_wrapped(self): def function1(*args, **kwargs): return args, kwargs function2 = wrapt.ObjectProxy(function1) self.assertEqual(function2, function1) self.assertEqual(function2.__wrapped__, function1) self.assertEqual(function2.__name__, function1.__name__) if sys.version_info >= (3, 3): self.assertEqual(function2.__qualname__, function1.__qualname__) function2.__wrapped__ = None self.assertFalse(hasattr(function1, '__wrapped__')) self.assertEqual(function2, None) self.assertEqual(function2.__wrapped__, None) self.assertFalse(hasattr(function2, '__name__')) if sys.version_info >= (3, 3): self.assertFalse(hasattr(function2, '__qualname__')) def function3(*args, **kwargs): return args, kwargs function2.__wrapped__ = function3 self.assertEqual(function2, function3) self.assertEqual(function2.__wrapped__, function3) self.assertEqual(function2.__name__, function3.__name__) if sys.version_info >= (3, 3): self.assertEqual(function2.__qualname__, function3.__qualname__) def test_delete_wrapped(self): def function1(*args, **kwargs): return args, kwargs function2 = wrapt.ObjectProxy(function1) def run(*args): del function2.__wrapped__ self.assertRaises(TypeError, run, ()) def test_proxy_attribute(self): pytest.skip("This test is failing, skipping it!") def function1(*args, **kwargs): return args, kwargs function2 = wrapt.ObjectProxy(function1) function2._self_variable = True self.assertFalse(hasattr(function1, '_self_variable')) self.assertTrue(hasattr(function2, '_self_variable')) self.assertEqual(function2._self_variable, True) del function2._self_variable self.assertFalse(hasattr(function1, '_self_variable')) self.assertFalse(hasattr(function2, '_self_variable')) self.assertEqual(getattr(function2, '_self_variable', None), None) def test_wrapped_attribute(self): def function1(*args, **kwargs): return args, kwargs function2 = wrapt.ObjectProxy(function1) function2.variable = True self.assertTrue(hasattr(function1, 'variable')) self.assertTrue(hasattr(function2, 'variable')) self.assertEqual(function2.variable, True) del function2.variable self.assertFalse(hasattr(function1, 'variable')) self.assertFalse(hasattr(function2, 'variable')) self.assertEqual(getattr(function2, 'variable', None), None) class TestNamingObjectProxy(unittest.TestCase): def test_class_object_name(self): # Test preservation of class __name__ attribute. target = objects.Target wrapper = wrapt.ObjectProxy(target) self.assertEqual(wrapper.__name__, target.__name__) def test_class_object_qualname(self): # Test preservation of class __qualname__ attribute. target = objects.Target wrapper = wrapt.ObjectProxy(target) try: __qualname__ = target.__qualname__ except AttributeError: pass else: self.assertEqual(wrapper.__qualname__, __qualname__) def test_class_module_name(self): # Test preservation of class __module__ attribute. target = objects.Target wrapper = wrapt.ObjectProxy(target) self.assertEqual(wrapper.__module__, target.__module__) def test_class_doc_string(self): # Test preservation of class __doc__ attribute. target = objects.Target wrapper = wrapt.ObjectProxy(target) self.assertEqual(wrapper.__doc__, target.__doc__) def test_instance_module_name(self): # Test preservation of instance __module__ attribute. target = objects.Target() wrapper = wrapt.ObjectProxy(target) self.assertEqual(wrapper.__module__, target.__module__) def test_instance_doc_string(self): # Test preservation of instance __doc__ attribute. target = objects.Target() wrapper = wrapt.ObjectProxy(target) self.assertEqual(wrapper.__doc__, target.__doc__) def test_function_object_name(self): # Test preservation of function __name__ attribute. target = objects.target wrapper = wrapt.ObjectProxy(target) self.assertEqual(wrapper.__name__, target.__name__) def test_function_object_qualname(self): # Test preservation of function __qualname__ attribute. target = objects.target wrapper = wrapt.ObjectProxy(target) try: __qualname__ = target.__qualname__ except AttributeError: pass else: self.assertEqual(wrapper.__qualname__, __qualname__) def test_function_module_name(self): # Test preservation of function __module__ attribute. target = objects.target wrapper = wrapt.ObjectProxy(target) self.assertEqual(wrapper.__module__, target.__module__) def test_function_doc_string(self): # Test preservation of function __doc__ attribute. target = objects.target wrapper = wrapt.ObjectProxy(target) self.assertEqual(wrapper.__doc__, target.__doc__) class TestTypeObjectProxy(unittest.TestCase): def test_class_of_class(self): # Test preservation of class __class__ attribute. target = objects.Target wrapper = wrapt.ObjectProxy(target) self.assertEqual(wrapper.__class__, target.__class__) self.assertTrue(isinstance(wrapper, type(target))) def test_class_of_instance(self): # Test preservation of instance __class__ attribute. target = objects.Target() wrapper = wrapt.ObjectProxy(target) self.assertEqual(wrapper.__class__, target.__class__) self.assertTrue(isinstance(wrapper, objects.Target)) self.assertTrue(isinstance(wrapper, objects.TargetBaseClass)) def test_class_of_function(self): # Test preservation of function __class__ attribute. target = objects.target wrapper = wrapt.ObjectProxy(target) self.assertEqual(wrapper.__class__, target.__class__) self.assertTrue(isinstance(wrapper, type(target))) class TestDirObjectProxy(unittest.TestCase): def test_dir_of_class(self): # Test preservation of class __dir__ attribute. target = objects.Target wrapper = wrapt.ObjectProxy(target) self.assertEqual(dir(wrapper), dir(target)) def test_vars_of_class(self): # Test preservation of class __dir__ attribute. target = objects.Target wrapper = wrapt.ObjectProxy(target) self.assertEqual(vars(wrapper), vars(target)) def test_dir_of_instance(self): # Test preservation of instance __dir__ attribute. target = objects.Target() wrapper = wrapt.ObjectProxy(target) self.assertEqual(dir(wrapper), dir(target)) def test_vars_of_instance(self): # Test preservation of instance __dir__ attribute. target = objects.Target() wrapper = wrapt.ObjectProxy(target) self.assertEqual(vars(wrapper), vars(target)) def test_dir_of_function(self): # Test preservation of function __dir__ attribute. target = objects.target wrapper = wrapt.ObjectProxy(target) self.assertEqual(dir(wrapper), dir(target)) def test_vars_of_function(self): # Test preservation of function __dir__ attribute. target = objects.target wrapper = wrapt.ObjectProxy(target) self.assertEqual(vars(wrapper), vars(target)) class TestCallingObject(unittest.TestCase): def test_function_no_args(self): _args = () _kwargs = {} def function(*args, **kwargs): return args, kwargs wrapper = wrapt.CallableObjectProxy(function) result = wrapper() self.assertEqual(result, (_args, _kwargs)) def test_function_args(self): _args = (1, 2) _kwargs = {} def function(*args, **kwargs): return args, kwargs wrapper = wrapt.CallableObjectProxy(function) result = wrapper(*_args) self.assertEqual(result, (_args, _kwargs)) def test_function_kwargs(self): _args = () _kwargs = { "one": 1, "two": 2 } def function(*args, **kwargs): return args, kwargs wrapper = wrapt.CallableObjectProxy(function) result = wrapper(**_kwargs) self.assertEqual(result, (_args, _kwargs)) def test_function_args_plus_kwargs(self): _args = (1, 2) _kwargs = { "one": 1, "two": 2 } def function(*args, **kwargs): return args, kwargs wrapper = wrapt.CallableObjectProxy(function) result = wrapper(*_args, **_kwargs) self.assertEqual(result, (_args, _kwargs)) def test_instancemethod_no_args(self): _args = () _kwargs = {} class Class(object): def function(self, *args, **kwargs): return args, kwargs wrapper = wrapt.CallableObjectProxy(Class().function) result = wrapper() self.assertEqual(result, (_args, _kwargs)) def test_instancemethod_args(self): _args = (1, 2) _kwargs = {} class Class(object): def function(self, *args, **kwargs): return args, kwargs wrapper = wrapt.CallableObjectProxy(Class().function) result = wrapper(*_args) self.assertEqual(result, (_args, _kwargs)) def test_instancemethod_kwargs(self): _args = () _kwargs = { "one": 1, "two": 2 } class Class(object): def function(self, *args, **kwargs): return args, kwargs wrapper = wrapt.CallableObjectProxy(Class().function) result = wrapper(**_kwargs) self.assertEqual(result, (_args, _kwargs)) def test_instancemethod_args_plus_kwargs(self): _args = (1, 2) _kwargs = { "one": 1, "two": 2 } class Class(object): def function(self, *args, **kwargs): return args, kwargs wrapper = wrapt.CallableObjectProxy(Class().function) result = wrapper(*_args, **_kwargs) self.assertEqual(result, (_args, _kwargs)) def test_instancemethod_via_class_no_args(self): _args = () _kwargs = {} class Class(object): def function(self, *args, **kwargs): return args, kwargs wrapper = wrapt.CallableObjectProxy(Class.function) result = wrapper(Class()) self.assertEqual(result, (_args, _kwargs)) def test_instancemethod_via_class_args(self): _args = (1, 2) _kwargs = {} class Class(object): def function(self, *args, **kwargs): return args, kwargs wrapper = wrapt.CallableObjectProxy(Class.function) result = wrapper(Class(), *_args) self.assertEqual(result, (_args, _kwargs)) def test_instancemethod_via_class_kwargs(self): _args = () _kwargs = { "one": 1, "two": 2 } class Class(object): def function(self, *args, **kwargs): return args, kwargs wrapper = wrapt.CallableObjectProxy(Class.function) result = wrapper(Class(), **_kwargs) self.assertEqual(result, (_args, _kwargs)) def test_instancemethod_via_class_args_plus_kwargs(self): _args = (1, 2) _kwargs = { "one": 1, "two": 2 } class Class(object): def function(self, *args, **kwargs): return args, kwargs wrapper = wrapt.CallableObjectProxy(Class.function) result = wrapper(Class(), *_args, **_kwargs) self.assertEqual(result, (_args, _kwargs)) def test_classmethod_no_args(self): _args = () _kwargs = {} class Class(object): @classmethod def function(cls, *args, **kwargs): return args, kwargs wrapper = wrapt.CallableObjectProxy(Class().function) result = wrapper() self.assertEqual(result, (_args, _kwargs)) def test_classmethod_args(self): _args = (1, 2) _kwargs = {} class Class(object): @classmethod def function(cls, *args, **kwargs): return args, kwargs wrapper = wrapt.CallableObjectProxy(Class().function) result = wrapper(*_args) self.assertEqual(result, (_args, _kwargs)) def test_classmethod_kwargs(self): _args = () _kwargs = { "one": 1, "two": 2 } class Class(object): @classmethod def function(cls, *args, **kwargs): return args, kwargs wrapper = wrapt.CallableObjectProxy(Class().function) result = wrapper(**_kwargs) self.assertEqual(result, (_args, _kwargs)) def test_classmethod_args_plus_kwargs(self): _args = (1, 2) _kwargs = { "one": 1, "two": 2 } class Class(object): @classmethod def function(cls, *args, **kwargs): return args, kwargs wrapper = wrapt.CallableObjectProxy(Class().function) result = wrapper(*_args, **_kwargs) self.assertEqual(result, (_args, _kwargs)) def test_classmethod_via_class_no_args(self): _args = () _kwargs = {} class Class(object): @classmethod def function(cls, *args, **kwargs): return args, kwargs wrapper = wrapt.CallableObjectProxy(Class.function) result = wrapper() self.assertEqual(result, (_args, _kwargs)) def test_classmethod_via_class_args(self): _args = (1, 2) _kwargs = {} class Class(object): @classmethod def function(cls, *args, **kwargs): return args, kwargs wrapper = wrapt.CallableObjectProxy(Class.function) result = wrapper(*_args) self.assertEqual(result, (_args, _kwargs)) def test_classmethod_via_class_kwargs(self): _args = () _kwargs = { "one": 1, "two": 2 } class Class(object): @classmethod def function(cls, *args, **kwargs): return args, kwargs wrapper = wrapt.CallableObjectProxy(Class.function) result = wrapper(**_kwargs) self.assertEqual(result, (_args, _kwargs)) def test_classmethod_via_class_args_plus_kwargs(self): _args = (1, 2) _kwargs = { "one": 1, "two": 2 } class Class(object): @classmethod def function(cls, *args, **kwargs): return args, kwargs wrapper = wrapt.CallableObjectProxy(Class.function) result = wrapper(*_args, **_kwargs) self.assertEqual(result, (_args, _kwargs)) def test_staticmethod_no_args(self): _args = () _kwargs = {} class Class(object): @staticmethod def function(*args, **kwargs): return args, kwargs wrapper = wrapt.CallableObjectProxy(Class().function) result = wrapper() self.assertEqual(result, (_args, _kwargs)) def test_staticmethod_args(self): _args = (1, 2) _kwargs = {} class Class(object): @staticmethod def function(*args, **kwargs): return args, kwargs wrapper = wrapt.CallableObjectProxy(Class().function) result = wrapper(*_args) self.assertEqual(result, (_args, _kwargs)) def test_staticmethod_kwargs(self): _args = () _kwargs = { "one": 1, "two": 2 } class Class(object): @staticmethod def function(*args, **kwargs): return args, kwargs wrapper = wrapt.CallableObjectProxy(Class().function) result = wrapper(**_kwargs) self.assertEqual(result, (_args, _kwargs)) def test_staticmethod_args_plus_kwargs(self): _args = (1, 2) _kwargs = { "one": 1, "two": 2 } class Class(object): @staticmethod def function(*args, **kwargs): return args, kwargs wrapper = wrapt.CallableObjectProxy(Class().function) result = wrapper(*_args, **_kwargs) self.assertEqual(result, (_args, _kwargs)) def test_staticmethod_via_class_no_args(self): _args = () _kwargs = {} class Class(object): @staticmethod def function(*args, **kwargs): return args, kwargs wrapper = wrapt.CallableObjectProxy(Class.function) result = wrapper() self.assertEqual(result, (_args, _kwargs)) def test_staticmethod_via_class_args(self): _args = (1, 2) _kwargs = {} class Class(object): @staticmethod def function(*args, **kwargs): return args, kwargs wrapper = wrapt.CallableObjectProxy(Class.function) result = wrapper(*_args) self.assertEqual(result, (_args, _kwargs)) def test_staticmethod_via_class_kwargs(self): _args = () _kwargs = { "one": 1, "two": 2 } class Class(object): @staticmethod def function(*args, **kwargs): return args, kwargs wrapper = wrapt.CallableObjectProxy(Class.function) result = wrapper(**_kwargs) self.assertEqual(result, (_args, _kwargs)) def test_staticmethod_via_class_args_plus_kwargs(self): _args = (1, 2) _kwargs = { "one": 1, "two": 2 } class Class(object): @staticmethod def function(*args, **kwargs): return args, kwargs wrapper = wrapt.CallableObjectProxy(Class.function) result = wrapper(*_args, **_kwargs) self.assertEqual(result, (_args, _kwargs)) class TestIterObjectProxy(unittest.TestCase): def test_iteration(self): items = [1, 2] wrapper = wrapt.ObjectProxy(items) result = [x for x in wrapper] self.assertEqual(result, items) class TestContextManagerObjectProxy(unittest.TestCase): def test_context_manager(self): class Class(object): def __enter__(self): return self def __exit__(*args, **kwargs): return instance = Class() wrapper = wrapt.ObjectProxy(instance) with wrapper: pass class TestEqualityObjectProxy(unittest.TestCase): def test_object_hash(self): def function1(*args, **kwargs): return args, kwargs function2 = wrapt.ObjectProxy(function1) self.assertEqual(hash(function2), hash(function1)) def test_mapping_key(self): def function1(*args, **kwargs): return args, kwargs function2 = wrapt.ObjectProxy(function1) table = dict() table[function1] = True self.assertTrue(table.get(function2)) table = dict() table[function2] = True self.assertTrue(table.get(function1)) def test_comparison(self): one = wrapt.ObjectProxy(1) two = wrapt.ObjectProxy(2) three = wrapt.ObjectProxy(3) self.assertTrue(two > 1) self.assertTrue(two >= 1) self.assertTrue(two < 3) self.assertTrue(two <= 3) self.assertTrue(two != 1) self.assertTrue(two == 2) self.assertTrue(two != 3) self.assertTrue(2 > one) self.assertTrue(2 >= one) self.assertTrue(2 < three) self.assertTrue(2 <= three) self.assertTrue(2 != one) self.assertTrue(2 == two) self.assertTrue(2 != three) self.assertTrue(two > one) self.assertTrue(two >= one) self.assertTrue(two < three) self.assertTrue(two <= three) self.assertTrue(two != one) self.assertTrue(two == two) self.assertTrue(two != three) class TestAsNumberObjectProxy(unittest.TestCase): def test_nonzero(self): true = wrapt.ObjectProxy(True) false = wrapt.ObjectProxy(False) self.assertTrue(true) self.assertFalse(false) self.assertTrue(bool(true)) self.assertFalse(bool(false)) self.assertTrue(not false) self.assertFalse(not true) def test_int(self): one = wrapt.ObjectProxy(1) self.assertEqual(int(one), 1) if not six.PY3: self.assertEqual(long(one), 1) def test_float(self): one = wrapt.ObjectProxy(1) self.assertEqual(float(one), 1.0) def test_add(self): one = wrapt.ObjectProxy(1) two = wrapt.ObjectProxy(2) self.assertEqual(one+two, 1+2) self.assertEqual(1+two, 1+2) self.assertEqual(one+2, 1+2) def test_sub(self): one = wrapt.ObjectProxy(1) two = wrapt.ObjectProxy(2) self.assertEqual(one-two, 1-2) self.assertEqual(1-two, 1-2) self.assertEqual(one-2, 1-2) def test_mul(self): two = wrapt.ObjectProxy(2) three = wrapt.ObjectProxy(3) self.assertEqual(two*three, 2*3) self.assertEqual(2*three, 2*3) self.assertEqual(two*3, 2*3) def test_div(self): # On Python 2 this will pick up div and on Python # 3 it will pick up truediv. two = wrapt.ObjectProxy(2) three = wrapt.ObjectProxy(3) self.assertEqual(two/three, 2/3) self.assertEqual(2/three, 2/3) self.assertEqual(two/3, 2/3) def test_mod(self): two = wrapt.ObjectProxy(2) three = wrapt.ObjectProxy(3) self.assertEqual(three//two, 3//2) self.assertEqual(3//two, 3//2) self.assertEqual(three//2, 3//2) def test_mod(self): two = wrapt.ObjectProxy(2) three = wrapt.ObjectProxy(3) self.assertEqual(three%two, 3%2) self.assertEqual(3%two, 3%2) self.assertEqual(three%2, 3%2) def test_divmod(self): two = wrapt.ObjectProxy(2) three = wrapt.ObjectProxy(3) self.assertEqual(divmod(three, two), divmod(3, 2)) self.assertEqual(divmod(3, two), divmod(3, 2)) self.assertEqual(divmod(three, 2), divmod(3, 2)) def test_pow(self): two = wrapt.ObjectProxy(2) three = wrapt.ObjectProxy(3) self.assertEqual(three**two, pow(3, 2)) self.assertEqual(3**two, pow(3, 2)) self.assertEqual(three**2, pow(3, 2)) self.assertEqual(pow(three, two), pow(3, 2)) self.assertEqual(pow(3, two), pow(3, 2)) self.assertEqual(pow(three, 2), pow(3, 2)) # Only PyPy implements __rpow__ for ternary pow(). if is_pypy: self.assertEqual(pow(three, two, 2), pow(3, 2, 2)) self.assertEqual(pow(3, two, 2), pow(3, 2, 2)) self.assertEqual(pow(three, 2, 2), pow(3, 2, 2)) def test_lshift(self): two = wrapt.ObjectProxy(2) three = wrapt.ObjectProxy(3) self.assertEqual(three<>two, 3>>2) self.assertEqual(3>>two, 3>>2) self.assertEqual(three>>2, 3>>2) def test_and(self): two = wrapt.ObjectProxy(2) three = wrapt.ObjectProxy(3) self.assertEqual(three&two, 3&2) self.assertEqual(3&two, 3&2) self.assertEqual(three&2, 3&2) def test_xor(self): two = wrapt.ObjectProxy(2) three = wrapt.ObjectProxy(3) self.assertEqual(three^two, 3^2) self.assertEqual(3^two, 3^2) self.assertEqual(three^2, 3^2) def test_or(self): two = wrapt.ObjectProxy(2) three = wrapt.ObjectProxy(3) self.assertEqual(three|two, 3|2) self.assertEqual(3|two, 3|2) self.assertEqual(three|2, 3|2) def test_iadd(self): value = wrapt.ObjectProxy(1) one = wrapt.ObjectProxy(1) value += 1 self.assertEqual(value, 2) self.assertEqual(type(value), wrapt.ObjectProxy) value += one self.assertEqual(value, 3) self.assertEqual(type(value), wrapt.ObjectProxy) def test_isub(self): value = wrapt.ObjectProxy(1) one = wrapt.ObjectProxy(1) value -= 1 self.assertEqual(value, 0) self.assertEqual(type(value), wrapt.ObjectProxy) value -= one self.assertEqual(value, -1) self.assertEqual(type(value), wrapt.ObjectProxy) def test_imul(self): value = wrapt.ObjectProxy(2) two = wrapt.ObjectProxy(2) value *= 2 self.assertEqual(value, 4) self.assertEqual(type(value), wrapt.ObjectProxy) value *= two self.assertEqual(value, 8) self.assertEqual(type(value), wrapt.ObjectProxy) def test_idiv(self): # On Python 2 this will pick up div and on Python # 3 it will pick up truediv. value = wrapt.ObjectProxy(2) two = wrapt.ObjectProxy(2) value /= 2 self.assertEqual(value, 2/2) self.assertEqual(type(value), wrapt.ObjectProxy) value /= two self.assertEqual(value, 2/2/2) self.assertEqual(type(value), wrapt.ObjectProxy) def test_ifloordiv(self): value = wrapt.ObjectProxy(2) two = wrapt.ObjectProxy(2) value //= 2 self.assertEqual(value, 2//2) self.assertEqual(type(value), wrapt.ObjectProxy) value //= two self.assertEqual(value, 2//2//2) self.assertEqual(type(value), wrapt.ObjectProxy) def test_imod(self): value = wrapt.ObjectProxy(10) two = wrapt.ObjectProxy(2) value %= 2 self.assertEqual(value, 10%2) self.assertEqual(type(value), wrapt.ObjectProxy) value %= two self.assertEqual(value, 10%2%2) self.assertEqual(type(value), wrapt.ObjectProxy) def test_ipow(self): value = wrapt.ObjectProxy(10) two = wrapt.ObjectProxy(2) value **= 2 self.assertEqual(value, 10**2) self.assertEqual(type(value), wrapt.ObjectProxy) value **= two self.assertEqual(value, 10**2**2) self.assertEqual(type(value), wrapt.ObjectProxy) def test_ilshift(self): value = wrapt.ObjectProxy(256) two = wrapt.ObjectProxy(2) value <<= 2 self.assertEqual(value, 256<<2) self.assertEqual(type(value), wrapt.ObjectProxy) value <<= two self.assertEqual(value, 256<<2<<2) self.assertEqual(type(value), wrapt.ObjectProxy) def test_irshift(self): value = wrapt.ObjectProxy(2) two = wrapt.ObjectProxy(2) value >>= 2 self.assertEqual(value, 2>>2) self.assertEqual(type(value), wrapt.ObjectProxy) value >>= two self.assertEqual(value, 2>>2>>2) self.assertEqual(type(value), wrapt.ObjectProxy) def test_iand(self): value = wrapt.ObjectProxy(1) two = wrapt.ObjectProxy(2) value &= 2 self.assertEqual(value, 1&2) self.assertEqual(type(value), wrapt.ObjectProxy) value &= two self.assertEqual(value, 1&2&2) self.assertEqual(type(value), wrapt.ObjectProxy) def test_ixor(self): value = wrapt.ObjectProxy(1) two = wrapt.ObjectProxy(2) value ^= 2 self.assertEqual(value, 1^2) self.assertEqual(type(value), wrapt.ObjectProxy) value ^= two self.assertEqual(value, 1^2^2) self.assertEqual(type(value), wrapt.ObjectProxy) def test_ior(self): value = wrapt.ObjectProxy(1) two = wrapt.ObjectProxy(2) value |= 2 self.assertEqual(value, 1|2) self.assertEqual(type(value), wrapt.ObjectProxy) value |= two self.assertEqual(value, 1|2|2) self.assertEqual(type(value), wrapt.ObjectProxy) def test_neg(self): value = wrapt.ObjectProxy(1) self.assertEqual(-value, -1) def test_pos(self): value = wrapt.ObjectProxy(1) self.assertEqual(+value, 1) def test_abs(self): value = wrapt.ObjectProxy(-1) self.assertEqual(abs(value), 1) def test_invert(self): value = wrapt.ObjectProxy(1) self.assertEqual(~value, ~1) def test_oct(self): value = wrapt.ObjectProxy(20) self.assertEqual(oct(value), oct(20)) def test_hex(self): value = wrapt.ObjectProxy(20) self.assertEqual(hex(value), hex(20)) def test_index(self): class Class(object): def __index__(self): return 1 value = wrapt.ObjectProxy(Class()) items = [0, 1, 2] self.assertEqual(items[value], items[1]) class TestAsSequenceObjectProxy(unittest.TestCase): def test_length(self): value = wrapt.ObjectProxy(list(range(3))) self.assertEqual(len(value), 3) def test_contains(self): value = wrapt.ObjectProxy(list(range(3))) self.assertTrue(2 in value) self.assertFalse(-2 in value) def test_getitem(self): value = wrapt.ObjectProxy(list(range(3))) self.assertEqual(value[1], 1) def test_setitem(self): value = wrapt.ObjectProxy(list(range(3))) value[1] = -1 self.assertEqual(value[1], -1) def test_delitem(self): value = wrapt.ObjectProxy(list(range(3))) self.assertEqual(len(value), 3) del value[1] self.assertEqual(len(value), 2) self.assertEqual(value[1], 2) def test_getslice(self): value = wrapt.ObjectProxy(list(range(5))) self.assertEqual(value[1:4], [1, 2, 3]) def test_setslice(self): value = wrapt.ObjectProxy(list(range(5))) value[1:4] = reversed(value[1:4]) self.assertEqual(value[1:4], [3, 2, 1]) def test_delslice(self): value = wrapt.ObjectProxy(list(range(5))) del value[1:4] self.assertEqual(len(value), 2) self.assertEqual(value, [0, 4]) class TestAsMappingObjectProxy(unittest.TestCase): def test_length(self): value = wrapt.ObjectProxy(dict.fromkeys(range(3), False)) self.assertEqual(len(value), 3) def test_contains(self): value = wrapt.ObjectProxy(dict.fromkeys(range(3), False)) self.assertTrue(2 in value) self.assertFalse(-2 in value) def test_getitem(self): value = wrapt.ObjectProxy(dict.fromkeys(range(3), False)) self.assertEqual(value[1], False) def test_setitem(self): value = wrapt.ObjectProxy(dict.fromkeys(range(3), False)) value[1] = True self.assertEqual(value[1], True) def test_delitem(self): value = wrapt.ObjectProxy(dict.fromkeys(range(3), False)) self.assertEqual(len(value), 3) del value[1] self.assertEqual(len(value), 2) class TestObjectRepresentationObjectProxy(unittest.TestCase): def test_str(self): value = wrapt.ObjectProxy(10) self.assertEqual(str(value), str(10)) value = wrapt.ObjectProxy((10,)) self.assertEqual(str(value), str((10,))) value = wrapt.ObjectProxy([10]) self.assertEqual(str(value), str([10])) value = wrapt.ObjectProxy({10:10}) self.assertEqual(str(value), str({10:10})) def test_repr(self): number = 10 value = wrapt.ObjectProxy(number) self.assertNotEqual(repr(value).find('ObjectProxy at'), -1) class TestDerivedClassCreation(unittest.TestCase): def test_derived_new(self): class DerivedObjectProxy(wrapt.ObjectProxy): def __new__(cls, wrapped): instance = super(DerivedObjectProxy, cls).__new__(cls) instance.__init__(wrapped) def __init__(self, wrapped): super(DerivedObjectProxy, self).__init__(wrapped) def function(): pass obj = DerivedObjectProxy(function) def test_derived_setattr(self): class DerivedObjectProxy(wrapt.ObjectProxy): def __init__(self, wrapped): self._self_attribute = True super(DerivedObjectProxy, self).__init__(wrapped) def function(): pass obj = DerivedObjectProxy(function) class DerivedClassAttributes(unittest.TestCase): def test_setup_class_attributes(self): def function(): pass class DerivedObjectProxy(wrapt.ObjectProxy): pass obj = DerivedObjectProxy(function) DerivedObjectProxy.ATTRIBUTE = 1 self.assertEqual(obj.ATTRIBUTE, 1) self.assertFalse(hasattr(function, 'ATTRIBUTE')) del DerivedObjectProxy.ATTRIBUTE self.assertFalse(hasattr(DerivedObjectProxy, 'ATTRIBUTE')) self.assertFalse(hasattr(obj, 'ATTRIBUTE')) self.assertFalse(hasattr(function, 'ATTRIBUTE')) def test_override_class_attributes(self): def function(): pass class DerivedObjectProxy(wrapt.ObjectProxy): ATTRIBUTE = 1 obj = DerivedObjectProxy(function) self.assertEqual(DerivedObjectProxy.ATTRIBUTE, 1) self.assertEqual(obj.ATTRIBUTE, 1) obj.ATTRIBUTE = 2 self.assertEqual(DerivedObjectProxy.ATTRIBUTE, 1) self.assertEqual(obj.ATTRIBUTE, 2) self.assertFalse(hasattr(function, 'ATTRIBUTE')) del DerivedObjectProxy.ATTRIBUTE self.assertFalse(hasattr(DerivedObjectProxy, 'ATTRIBUTE')) self.assertEqual(obj.ATTRIBUTE, 2) self.assertFalse(hasattr(function, 'ATTRIBUTE')) def test_class_properties(self): def function(): pass class DerivedObjectProxy(wrapt.ObjectProxy): def __init__(self, wrapped): super(DerivedObjectProxy, self).__init__(wrapped) self._self_attribute = 1 @property def ATTRIBUTE(self): return self._self_attribute @ATTRIBUTE.setter def ATTRIBUTE(self, value): self._self_attribute = value @ATTRIBUTE.deleter def ATTRIBUTE(self): del self._self_attribute obj = DerivedObjectProxy(function) self.assertEqual(obj.ATTRIBUTE, 1) obj.ATTRIBUTE = 2 self.assertEqual(obj.ATTRIBUTE, 2) self.assertFalse(hasattr(function, 'ATTRIBUTE')) del obj.ATTRIBUTE self.assertFalse(hasattr(obj, 'ATTRIBUTE')) self.assertFalse(hasattr(function, 'ATTRIBUTE')) obj.ATTRIBUTE = 1 self.assertEqual(obj.ATTRIBUTE, 1) obj.ATTRIBUTE = 2 self.assertEqual(obj.ATTRIBUTE, 2) self.assertFalse(hasattr(function, 'ATTRIBUTE')) del obj.ATTRIBUTE self.assertFalse(hasattr(obj, 'ATTRIBUTE')) self.assertFalse(hasattr(function, 'ATTRIBUTE')) class OverrideAttributeAccess(unittest.TestCase): def test_attr_functions(self): def function(): pass proxy = wrapt.ObjectProxy(function) self.assertTrue(hasattr(proxy, '__getattr__')) self.assertTrue(hasattr(proxy, '__setattr__')) self.assertTrue(hasattr(proxy, '__delattr__')) def test_override_getattr(self): def function(): pass accessed = [] class DerivedObjectProxy(wrapt.ObjectProxy): def __getattr__(self, name): accessed.append(name) try: __getattr__ = super(DerivedObjectProxy, self).__getattr__ except AttributeError as e: raise RuntimeError(str(e)) return __getattr__(name) function.attribute = 1 proxy = DerivedObjectProxy(function) self.assertEqual(proxy.attribute, 1) self.assertTrue('attribute' in accessed) class CallableFunction(unittest.TestCase): def test_proxy_hasattr_call(self): proxy = wrapt.ObjectProxy(None) self.assertFalse(hasattr(proxy, '__call__')) def test_proxy_getattr_call(self): proxy = wrapt.ObjectProxy(None) self.assertEqual(getattr(proxy, '__call__', None), None) def test_proxy_is_callable(self): proxy = wrapt.ObjectProxy(None) self.assertFalse(callable(proxy)) def test_callable_proxy_hasattr_call(self): proxy = wrapt.CallableObjectProxy(None) self.assertTrue(hasattr(proxy, '__call__')) def test_callable_proxy_getattr_call(self): proxy = wrapt.CallableObjectProxy(None) self.assertTrue(getattr(proxy, '__call__', None), None) def test_callable_proxy_is_callable(self): proxy = wrapt.CallableObjectProxy(None) self.assertTrue(callable(proxy)) class SpecialMethods(unittest.TestCase): def test_class_bytes(self): if six.PY3: class Class(object): def __bytes__(self): return b'BYTES' instance = Class() proxy = wrapt.ObjectProxy(instance) self.assertEqual(bytes(instance), bytes(proxy)) def test_str_format(self): instance = 'abcd' proxy = wrapt.ObjectProxy(instance) self.assertEqual(format(instance, ''), format(proxy, '')) def test_list_reversed(self): instance = [1, 2] proxy = wrapt.ObjectProxy(instance) self.assertEqual(list(reversed(instance)), list(reversed(proxy))) def test_decimal_complex(self): import decimal instance = decimal.Decimal(123) proxy = wrapt.ObjectProxy(instance) self.assertEqual(complex(instance), complex(proxy)) def test_fractions_round(self): import fractions instance = fractions.Fraction('1/2') proxy = wrapt.ObjectProxy(instance) self.assertEqual(round(instance), round(proxy)) if __name__ == '__main__': unittest.main()