def test_dict(self):
meta = {
'exclude': ['foo'],
'readonly': ['bar'],
'dynamic': False,
'alias': 'spam.eggs',
'synonym_attrs': None,
'amf3': True,
'static': ['baz'],
'external': True
}
class A:
__amf__ = meta
class B(object):
__amf__ = meta
ret = {
'readonly_attrs': ['bar'],
'static_attrs': ['baz'],
'dynamic': False,
'alias': 'spam.eggs',
'amf3': True,
'exclude_attrs': ['foo'],
'synonym_attrs': None,
'external': True
}
self.assertEqual(get_class_meta(A), ret)
self.assertEqual(get_class_meta(B), ret)
def getClassAlias(self, klass):
"""
Gets a class alias based on the supplied C{klass}. If one is not found
in the global context, one is created locally.
If you supply a string alias and the class is not registered,
L{miniamf.UnknownClassAlias} will be raised.
@param klass: A class object or string alias.
@return: The L{miniamf.ClassAlias} instance that describes C{klass}
"""
try:
return self._class_aliases[klass]
except KeyError:
pass
try:
alias = self._class_aliases[klass] = miniamf.get_class_alias(klass)
except miniamf.UnknownClassAlias:
if isinstance(klass, six.string_types):
raise
# no alias has been found yet .. check subclasses
alias = util.get_class_alias(klass) or miniamf.ClassAlias
meta = util.get_class_meta(klass)
alias = alias(klass, defer=True, **meta)
self._class_aliases[klass] = alias
return alias
def test_no_meta(self):
class A:
pass
class B(object):
pass
empty = {
'readonly_attrs': None,
'static_attrs': None,
'synonym_attrs': None,
'dynamic': None,
'alias': None,
'amf3': None,
'exclude_attrs': None,
'external': None
}
self.assertEqual(get_class_meta(A), empty)
self.assertEqual(get_class_meta(B), empty)
def test_synonym(self):
class A:
class __amf__:
synonym = {'foo': 'bar'}
class B(object):
class __amf__:
synonym = {'foo': 'bar'}
meta = {
'exclude_attrs': None,
'readonly_attrs': None,
'synonym_attrs': {'foo': 'bar'},
'dynamic': None,
'alias': None,
'amf3': None,
'static_attrs': None,
'external': None
}
self.assertEqual(get_class_meta(A), meta)
self.assertEqual(get_class_meta(B), meta)
def test_external(self):
class A:
class __amf__:
external = True
class B(object):
class __amf__:
external = True
meta = {
'exclude_attrs': None,
'synonym_attrs': None,
'readonly_attrs': None,
'dynamic': None,
'alias': None,
'amf3': None,
'static_attrs': None,
'external': True
}
self.assertEqual(get_class_meta(A), meta)
self.assertEqual(get_class_meta(B), meta)
def test_readonly(self):
class A:
class __amf__:
readonly = ['foo', 'bar']
class B(object):
class __amf__:
readonly = ['foo', 'bar']
meta = {
'exclude_attrs': None,
'readonly_attrs': ['foo', 'bar'],
'synonym_attrs': None,
'dynamic': None,
'alias': None,
'amf3': None,
'static_attrs': None,
'external': None,
}
self.assertEqual(get_class_meta(A), meta)
self.assertEqual(get_class_meta(B), meta)
def test_alias(self):
class A:
class __amf__:
alias = 'foo.bar.Spam'
class B(object):
class __amf__:
alias = 'foo.bar.Spam'
meta = {
'readonly_attrs': None,
'static_attrs': None,
'synonym_attrs': None,
'dynamic': None,
'alias': 'foo.bar.Spam',
'amf3': None,
'exclude_attrs': None,
'external': None
}
self.assertEqual(get_class_meta(A), meta)
self.assertEqual(get_class_meta(B), meta)