def test_dir(self):
class X(object):
def __dir__(self):
return ['a', 'b', 'c']
x = Proxy(lambda: X())
self.assertListEqual(dir(x), ['a', 'b', 'c'])
class Y(object):
def __dir__(self):
raise RuntimeError()
y = Proxy(lambda: Y())
self.assertListEqual(dir(y), [])
def test_dir(self):
class X(object):
def __dir__(self):
return ['a', 'b', 'c']
x = Proxy(lambda: X())
assert dir(x) == ['a', 'b', 'c']
class Y(object):
def __dir__(self):
raise RuntimeError()
y = Proxy(lambda: Y())
assert dir(y) == []
def test_coerce(self):
class O(object):
def __coerce__(self, other):
return self, other
o = Proxy(O)
assert o.__coerce__(3)
def test_reduce(self):
class X(object):
def __reduce__(self):
return 123
x = Proxy(lambda: X())
assert x.__reduce__() == 123
def test_slots(self):
class X(object):
__slots__ = ()
x = Proxy(X)
with pytest.raises(AttributeError):
x.__dict__
def test_reduce(self):
class X(object):
def __reduce__(self):
return 123
x = Proxy(lambda: X())
self.assertEqual(x.__reduce__(), 123)
def test_name(self):
def real():
"""real function"""
return 'REAL'
x = Proxy(lambda: real, name='xyz')
self.assertEqual(x.__name__, 'xyz')
y = Proxy(lambda: real)
self.assertEqual(y.__name__, 'real')
self.assertEqual(x.__doc__, 'real function')
self.assertEqual(x.__class__, type(real))
self.assertEqual(x.__dict__, real.__dict__)
self.assertEqual(repr(x), repr(real))
def __call__(self):
def _lookup():
rv = self.top
if rv is None:
raise RuntimeError('object unbound')
return rv
return Proxy(_lookup)
def test_index(self):
class O(object):
def __index__(self):
return 1
o = Proxy(O)
self.assertEqual(o.__index__(), 1)
def test_complex_cast(self):
class O(object):
def __complex__(self):
return complex(10.333)
o = Proxy(O)
self.assertEqual(o.__complex__(), complex(10.333))
def test_getsetdel_attr(self):
if sys.version_info < (2, 6):
raise SkipTest('Not relevant for Py2.5')
class X(object):
a = 1
b = 2
c = 3
def __dir__(self):
return ['a', 'b', 'c']
v = X()
x = Proxy(lambda: v)
self.assertListEqual(x.__members__, ['a', 'b', 'c'])
self.assertEqual(x.a, 1)
self.assertEqual(x.b, 2)
self.assertEqual(x.c, 3)
setattr(x, 'a', 10)
self.assertEqual(x.a, 10)
del(x.a)
self.assertEqual(x.a, 1)
def test_nonzero(self):
class X(object):
def __nonzero__(self):
return False
x = Proxy(lambda: X())
self.assertFalse(x)
def test_index(self):
class O(object):
def __index__(self):
return 1
o = Proxy(O)
assert o.__index__() == 1
def test_complex_cast(self):
class O(object):
def __complex__(self):
return complex(10.333)
o = Proxy(O)
assert o.__complex__() == complex(10.333)
def test_call(self):
class X:
def __call__(self):
return 1234
assert Proxy(lambda: X())() == 1234
def test_hash(self):
class X:
def __hash__(self):
return 1234
assert hash(Proxy(lambda: X())) == 1234
def test_dir(self):
if sys.version_info < (2, 6):
raise SkipTest('Not relevant for Py2.5')
class X(object):
def __dir__(self):
return ['a', 'b', 'c']
x = Proxy(lambda: X())
self.assertListEqual(dir(x), ['a', 'b', 'c'])
class Y(object):
def __dir__(self):
raise RuntimeError()
y = Proxy(lambda: Y())
self.assertListEqual(dir(y), [])
def test_call(self):
class X(object):
def __call__(self):
return 1234
self.assertEqual(Proxy(lambda: X())(), 1234)
def test_name(self):
def real():
"""real function"""
return "REAL"
x = Proxy(lambda: real, name="xyz")
self.assertEqual(x.__name__, "xyz")
y = Proxy(lambda: real)
self.assertEqual(y.__name__, "real")
self.assertEqual(x.__doc__, "real function")
self.assertEqual(x.__class__, type(real))
self.assertEqual(x.__dict__, real.__dict__)
self.assertEqual(repr(x), repr(real))
def test_hash(self):
class X(object):
def __hash__(self):
return 1234
self.assertEqual(hash(Proxy(lambda: X())), 1234)
def test_name(self):
def real():
"""real function"""
return 'REAL'
x = Proxy(lambda: real, name='xyz')
assert x.__name__ == 'xyz'
y = Proxy(lambda: real)
assert y.__name__ == 'real'
assert x.__doc__ == 'real function'
assert x.__class__ == type(real)
assert x.__dict__ == real.__dict__
assert repr(x) == repr(real)
assert x.__module__
def test_bool(self):
class X(object):
def __bool__(self):
return False
__nonzero__ = __bool__
x = Proxy(lambda: X())
assert not x
def test_dictproxy(self):
v = {}
x = Proxy(lambda: v)
x["foo"] = 42
self.assertEqual(x["foo"], 42)
self.assertEqual(len(x), 1)
self.assertIn("foo", x)
del(x["foo"])
with self.assertRaises(KeyError):
x["foo"]
self.assertTrue(iter(x))
def test_dictproxy(self):
v = {}
x = Proxy(lambda: v)
x['foo'] = 42
assert x['foo'] == 42
assert len(x) == 1
assert 'foo' in x
del (x['foo'])
with pytest.raises(KeyError):
x['foo']
assert iter(x)
def test_unicode(self):
class X(object):
def __unicode__(self):
return u'UNICODE'
def __repr__(self):
return 'REPR'
x = Proxy(lambda: X())
self.assertEqual(unicode(x), u'UNICODE')
del (X.__unicode__)
self.assertEqual(unicode(x), 'REPR')
def test_unicode(self):
class X(object):
def __unicode__(self):
return u"UNICODE"
def __repr__(self):
return "REPR"
x = Proxy(lambda: X())
self.assertEqual(unicode(x), u"UNICODE")
del(X.__unicode__)
self.assertEqual(unicode(x), "REPR")
def test_listproxy(self):
v = []
x = Proxy(lambda: v)
x.append(1)
x.extend([2, 3, 4])
self.assertEqual(x[0], 1)
self.assertEqual(x[:-1], [1, 2, 3])
del(x[-1])
self.assertEqual(x[:-1], [1, 2])
x[0] = 10
self.assertEqual(x[0], 10)
self.assertIn(10, x)
self.assertEqual(len(x), 3)
self.assertTrue(iter(x))
def test_unicode(self):
class X(object):
def __unicode__(self):
return 'UNICODE'
__str__ = __unicode__
def __repr__(self):
return 'REPR'
x = Proxy(lambda: X())
self.assertEqual(string(x), 'UNICODE')
del (X.__unicode__)
del (X.__str__)
self.assertEqual(string(x), 'REPR')
def get_connection(name, **kw):
cnf = xconf.get_connection(name)
# print(cnf)
if cnf:
cnf = cnf.copy()
else:
cnf = {}
dsn = cnf.pop('dsn', None) if cnf else None
if not dsn:
raise ConfigError(u'不存在的连接 %s 设置' % name)
pd = urlparse(dsn)
scheme = pd.scheme
if scheme == 'redis':
return Proxy(functools.partial(get_redis, dsn))
elif scheme == 'mongodb':
return Proxy(functools.partial(get_mongodb, dsn, **cnf))
elif scheme == 'mysql':
return Proxy(functools.partial(get_mysql, dsn, **cnf))
elif scheme == 'influxdb':
return Proxy(functools.partial(get_influxdb, dsn))
else:
cnf['dsn'] = dsn
raise ConfigError(u'连接 %s 设置错误 %s' % (name, cnf))
def test_unicode(self):
@python_2_unicode_compatible
class X(object):
def __unicode__(self):
return 'UNICODE'
__str__ = __unicode__
def __repr__(self):
return 'REPR'
x = Proxy(lambda: X())
assert string(x) == 'UNICODE'
del (X.__unicode__)
del (X.__str__)
assert string(x) == 'REPR'
