def tearDown(self):
self.class_mapper.unmapClass(self.TestObject)
self.class_mapper.unmapClass(self.TestSubObject)
if use_pyamf is True:
pyamf.unregister_class(self.TestObject)
pyamf.unregister_class(self.TestSubObject)
def test_setstate_classic(self):
self.executed = False
class Foo:
tc = self
def __init__(self, *args, **kwargs):
self.tc.fail("__init__ called")
def __setstate__(self, state):
self.tc.executed = True
self.__dict__.update(state)
pyamf.register_class(Foo, 'foo')
self.buf.write(
'\x10\x00\x03\x66\x6f\x6f\x00\x04\x65\x67\x67\x73\x01\x01\x00\x04')
self.buf.write(
'\x73\x70\x61\x6d\x02\x00\x05\x68\x65\x6c\x6c\x6f\x00\x00\x09')
self.buf.seek(0)
foo = self.decoder.readElement()
self.assertTrue(self.executed)
self.assertTrue(isinstance(foo, Foo))
self.assertEquals(foo.spam, 'hello')
self.assertEquals(foo.eggs, True)
pyamf.unregister_class(Foo)
def tearDown(self):
import pyamf
pyamf.unregister_class(status.Status)
if self._old_alias:
pyamf.register_class(self._old_alias)
def test_klass(self):
alias = pyamf.register_class(Spam, 'spam.eggs')
pyamf.unregister_class(Spam)
self.assertTrue('spam.eggs' not in pyamf.CLASS_CACHE.keys())
self.assertTrue(Spam not in pyamf.CLASS_CACHE.keys())
self.assertTrue(alias not in pyamf.CLASS_CACHE)
def tearDown(self):
import pyamf
pyamf.unregister_class(status.Status)
if self._old_alias:
pyamf.register_class(self._old_alias)
def tearDown(self):
self.class_mapper.unmapClass(self.TestObject)
self.class_mapper.unmapClass(self.TestSubObject)
if use_pyamf is True:
pyamf.unregister_class(self.TestObject)
pyamf.unregister_class(self.TestSubObject)
def test_klass(self):
alias = pyamf.register_class(Spam, 'spam.eggs')
pyamf.unregister_class(Spam)
self.assertTrue('spam.eggs' not in pyamf.CLASS_CACHE.keys())
self.assertTrue(Spam not in pyamf.CLASS_CACHE.keys())
self.assertTrue(alias not in pyamf.CLASS_CACHE)
def test_simple(self):
class A(object):
pass
pyamf.register_class(A, 'A', attrs=['a'])
class B(A):
pass
pyamf.register_class(B, 'B', attrs=['b'])
x = B()
x.a = 'spam'
x.b = 'eggs'
stream = util.BufferedByteStream()
encoder = pyamf._get_encoder_class(pyamf.AMF0)(stream)
encoder.writeElement(x)
self.assertEquals(stream.getvalue(), '\x10\x00\x01B\x00\x01b\x02\x00'
'\x04eggs\x00\x01a\x02\x00\x04spam\x00\x00\t')
pyamf.unregister_class(A)
pyamf.unregister_class(B)
def test_setstate_classic(self):
self.executed = False
class Foo:
tc = self
def __init__(self, *args, **kwargs):
self.tc.fail("__init__ called")
def __setstate__(self, state):
self.tc.executed = True
self.__dict__.update(state)
pyamf.register_class(Foo, 'foo')
self.buf.write('\x10\x00\x03\x66\x6f\x6f\x00\x04\x65\x67\x67\x73\x01\x01\x00\x04')
self.buf.write('\x73\x70\x61\x6d\x02\x00\x05\x68\x65\x6c\x6c\x6f\x00\x00\x09')
self.buf.seek(0)
foo = self.decoder.readElement()
self.assertTrue(self.executed)
self.assertTrue(isinstance(foo, Foo))
self.assertEquals(foo.spam, 'hello')
self.assertEquals(foo.eggs, True)
pyamf.unregister_class(Foo)
def test_dynamic(self):
class Foo(pyamf.ASObject):
pass
def attr_func(obj):
self.assertTrue(isinstance(obj, Foo))
return ['hello']
x = Foo()
x.foo = 'bar'
x.hello = 'world'
y = Foo()
y.hello = x.hello
pyamf.register_class(Foo, 'x', attr_func=attr_func,
metadata=['dynamic'])
self._run([(x, '\x10\x00\x01x\x00\x03foo\x02\x00\x03bar\x00\x05hello'
'\x02\x00\x05world\x00\x00\t')])
pyamf.unregister_class(Foo)
pyamf.register_class(Foo, 'x', attrs=['hello'], attr_func=attr_func,
metadata=['dynamic'])
self._run([(x, '\x10\x00\x01x\x00\x03foo\x02\x00\x03bar\x00\x05hello'
'\x02\x00\x05world\x00\x00\t')])
pyamf.unregister_class(Foo)
pyamf.register_class(Foo, 'x', attrs=['foo'], attr_func=attr_func,
metadata=['dynamic'])
self._run([(x, '\x10\x00\x01x\x00\x03foo\x02\x00\x03bar\x00\x05hello'
'\x02\x00\x05world\x00\x00\t')])
def test_simple(self):
class A(object):
pass
pyamf.register_class(A, 'A', attrs=['a'])
class B(A):
pass
pyamf.register_class(B, 'B', attrs=['b'])
x = B()
x.a = 'spam'
x.b = 'eggs'
stream = util.BufferedByteStream()
encoder = pyamf._get_encoder_class(pyamf.AMF0)(stream)
encoder.writeElement(x)
self.assertEquals(
stream.getvalue(), '\x10\x00\x01B\x00\x01a\x02\x00'
'\x04spam\x00\x01b\x02\x00\x04eggs\x00\x00\t')
pyamf.unregister_class(A)
pyamf.unregister_class(B)
def test_force_amf3(self):
pyamf.register_class(Spam, 'spam.eggs', metadata=['amf3'])
x = Spam()
x.x = 'y'
self._run([(x, '\x11\n\x0b\x13spam.eggs\x03x\x06\x03y\x01')])
pyamf.unregister_class(Spam)
def test_dynamic(self):
pyamf.register_class(Spam, 'abc.xyz', metadata='dynamic')
x = Spam({'spam': 'eggs'})
self.encoder.writeElement(x)
self.assertEquals(self.stream.getvalue(), '\n\x0b\x0fabc.xyz\tspam\x06\teggs\x01')
pyamf.unregister_class(Spam)
def test_class_references(self):
pyamf.register_class(Spam, 'abc.xyz')
x = Spam({'spam': 'eggs'})
y = Spam({'spam': 'baz'})
self.encoder.writeElement(x)
pyamf.unregister_class(Spam)
def test_dynamic(self):
def attr_func(obj):
self.assertTrue(isinstance(obj, Spam))
return ['hello']
x = Spam()
x.foo = 'bar'
x.hello = 'world'
pyamf.register_class(Spam, attr_func=attr_func, metadata=['dynamic'])
self._run([(x, '\x03\x00\x05hello\x02\x00\x05world\x00\x00\t')])
pyamf.unregister_class(Spam)
# try duplicate attributes
pyamf.register_class(Spam,
attrs=['hello'],
attr_func=attr_func,
metadata=['dynamic'])
self._run([(x, '\x03\x00\x05hello\x02\x00\x05world\x00\x00\t')])
pyamf.unregister_class(Spam)
pyamf.register_class(Spam,
attrs=['foo'],
attr_func=attr_func,
metadata=['dynamic'])
self._run([(x, '\x03\x00\x03foo\x02\x00\x03bar\x00\x05hello\x02\x00'
'\x05world\x00\x00\t')])
pyamf.unregister_class(Spam)
# and now typedobject
pyamf.register_class(Spam,
'x',
attr_func=attr_func,
metadata=['dynamic'])
self._run([(x, '\x10\x00\x01x\x00\x05hello\x02\x00\x05world\x00\x00\t')
])
pyamf.unregister_class(Spam)
pyamf.register_class(Spam,
'x',
attrs=['hello'],
attr_func=attr_func,
metadata=['dynamic'])
self._run([(x, '\x10\x00\x01x\x00\x05hello\x02\x00\x05world\x00\x00\t')
])
pyamf.unregister_class(Spam)
pyamf.register_class(Spam,
'x',
attrs=['foo'],
attr_func=attr_func,
metadata=['dynamic'])
self._run([(x, '\x10\x00\x01x\x00\x03foo\x02\x00\x03bar\x00\x05hello'
'\x02\x00\x05world\x00\x00\t')])
def test_force_amf3(self):
pyamf.register_class(Spam, 'spam.eggs', metadata=['amf3'])
x = Spam()
x.x = 'y'
self._run([
(x, '\x11\n\x0b\x13spam.eggs\x03x\x06\x03y\x01')])
pyamf.unregister_class(Spam)
def test_typed_object(self):
pyamf.register_class(Spam, alias='org.pyamf.spam')
x = Spam()
x.baz = 'hello'
self.encoder.writeElement(x)
self.assertEquals(self.buf.getvalue(),
'\x10\x00\x0eorg.pyamf.spam\x00\x03baz\x02\x00\x05hello\x00\x00\t')
pyamf.unregister_class(Spam)
def tearDown(self):
try:
self.jessica.delete()
except:
pass
if self.jessica_expando.is_saved():
self.jessica_expando.delete()
try:
pyamf.unregister_class(PetModel)
except:
pass
def tearDown(self):
try:
self.jessica.delete()
except:
pass
if self.jessica_expando.is_saved():
self.jessica_expando.delete()
try:
pyamf.unregister_class(PetModel)
except:
pass
def test_typed_object(self):
pyamf.register_class(Spam, alias='org.pyamf.spam')
x = Spam()
x.baz = 'hello'
self.encoder.writeElement(x)
self.assertEquals(
self.buf.getvalue(),
'\x10\x00\x0eorg.pyamf.spam\x00\x03baz\x02\x00\x05hello\x00\x00\t')
pyamf.unregister_class(Spam)
def test_dynamic(self):
def attr_func(obj):
self.assertTrue(isinstance(obj, Spam))
return ['hello']
x = Spam()
x.foo = 'bar'
x.hello = 'world'
pyamf.register_class(Spam, attr_func=attr_func, metadata=['dynamic'])
self._run([(x, '\x03\x00\x05hello\x02\x00\x05world\x00\x00\t')])
pyamf.unregister_class(Spam)
# try duplicate attributes
pyamf.register_class(Spam, attrs=['hello'], attr_func=attr_func,
metadata=['dynamic'])
self._run([(x, '\x03\x00\x05hello\x02\x00\x05world\x00\x00\t')])
pyamf.unregister_class(Spam)
pyamf.register_class(Spam, attrs=['foo'], attr_func=attr_func,
metadata=['dynamic'])
self._run([
(x, ('\x03', (
'\x00\x03foo\x02\x00\x03bar',
'\x00\x05hello\x02\x00\x05world'
), '\x00\x00\t'))])
pyamf.unregister_class(Spam)
# and now typedobject
pyamf.register_class(Spam, 'x', attr_func=attr_func,
metadata=['dynamic'])
self._run([(x,
'\x10\x00\x01x\x00\x05hello\x02\x00\x05world\x00\x00\t')])
pyamf.unregister_class(Spam)
pyamf.register_class(Spam, 'x', attrs=['hello'], attr_func=attr_func,
metadata=['dynamic'])
self._run([(x,
'\x10\x00\x01x\x00\x05hello\x02\x00\x05world\x00\x00\t')])
pyamf.unregister_class(Spam)
pyamf.register_class(Spam, 'x', attrs=['foo'], attr_func=attr_func,
metadata=['dynamic'])
self._run([
(x, ('\x10\x00\x01x', (
'\x00\x03foo\x02\x00\x03bar',
'\x00\x05hello\x02\x00\x05world'
), '\x00\x00\t'))])
def test_dynamic(self):
class Foo(pyamf.ASObject):
pass
x = Foo()
x.foo = 'bar'
alias = pyamf.register_class(Foo, 'x')
alias.exclude_attrs = ['hello']
self._run([(x, '\x10\x00\x01x\x00\x03foo\x02\x00\x03bar\x00\x05hello'
'\x02\x00\x05world\x00\x00\t')])
pyamf.unregister_class(Foo)
def test_dynamic(self):
class Foo(pyamf.ASObject):
pass
x = Foo()
x.foo = 'bar'
alias = pyamf.register_class(Foo, 'x')
alias.exclude_attrs = ['hello']
self._run([(x, '\x10\x00\x01x\x00\x03foo\x02\x00\x03bar\x00\x05hello'
'\x02\x00\x05world\x00\x00\t')])
pyamf.unregister_class(Foo)
def test_combined(self):
def wf(obj):
return ['eggs']
pyamf.register_class(Spam, 'abc.xyz', attrs=['spam'], attr_func=wf)
x = Spam({'spam': 'foo', 'eggs': 'bar'})
self.encoder.writeElement(x)
buf = self.stream.getvalue()
self.assertEquals(buf, '\n\x1b\x0fabc.xyz\tspam\x06\x07foo\teggs\x06\x07bar\x01')
pyamf.unregister_class(Spam)
def test_old_style_classes(self):
class Person:
pass
pyamf.register_class(Person, 'spam.eggs.Person')
u = Person()
u.family_name = 'Doe'
u.given_name = 'Jane'
self.encoder.writeElement(u)
self.assertEquals(self.buf.getvalue(), '\n\x0b!spam.eggs.Person\x17'
'family_name\x06\x07Doe\x15given_name\x06\tJane\x01')
pyamf.unregister_class(Person)
def test_static(self):
pyamf.register_class(Spam, 'abc.xyz', metadata='static', attrs=[])
x = Spam({'spam': 'eggs'})
self.encoder.writeElement(x)
self.assertEquals(self.stream.getvalue(), '\n\x03\x0fabc.xyz')
pyamf.unregister_class(Spam)
self.stream.truncate()
self.encoder.context.clear()
pyamf.register_class(Spam, 'abc.xyz', metadata='static', attrs=['spam'])
x = Spam({'spam': 'eggs'})
self.encoder.writeElement(x)
self.assertEquals(self.stream.getvalue(), '\n\x13\x0fabc.xyz\tspam\x06\teggs')
pyamf.unregister_class(Spam)
def test_object(self):
self._run([
({'a': u'spam', 'b': 5},
'\n\x0b\x01\x03a\x06\tspam\x03b\x04\x05\x01')])
pyamf.register_class(Spam, 'org.pyamf.spam')
obj = Spam()
obj.baz = 'hello'
self.encoder.writeElement(obj)
self.assertEqual(self.buf.getvalue(), '\n\x0b\x1dorg.pyamf.spam\x07baz'
'\x06\x0bhello\x01')
pyamf.unregister_class(Spam)
def test_get_alias(self):
pyamf.register_class(Spam, 'spam.eggs')
x = amf3.ClassDefinition('spam.eggs')
alias = x.getClassAlias()
self.assertEquals(alias.klass, Spam)
self.assertEquals(alias.alias, 'spam.eggs')
pyamf.unregister_class(Spam)
x = amf3.ClassDefinition(None)
self.assertRaises(pyamf.UnknownClassAlias, x.getClassAlias)
x = amf3.ClassDefinition('')
self.assertRaises(pyamf.UnknownClassAlias, x.getClassAlias)
def test_external(self):
pyamf.register_class(Spam, 'abc.xyz', metadata=['external'])
x = Spam({'spam': 'eggs'})
self.encoder.writeElement(x)
buf = self.stream.getvalue()
# an inline object with and inline class-def, encoding = 0x01, 1 attr
self.assertEquals(buf[:2], '\x0a\x07')
# class alias name
self.assertEquals(buf[2:10], '\x0fabc.xyz')
self.assertEquals(len(buf), 10)
pyamf.unregister_class(Spam)
def test_static(self):
alias = pyamf.register_class(Spam, 'abc.xyz')
alias.dynamic = False
x = Spam({'spam': 'eggs'})
self.encoder.writeElement(x)
self.assertEqual(self.buf.getvalue(), '\n\x03\x0fabc.xyz')
pyamf.unregister_class(Spam)
self.buf.truncate()
self.encoder.context.clear()
alias = pyamf.register_class(Spam, 'abc.xyz')
alias.dynamic = False
alias.static_attrs = ['spam']
x = Spam({'spam': 'eggs', 'foo': 'bar'})
self.encoder.writeElement(x)
self.assertEqual(self.buf.getvalue(), '\n\x13\x0fabc.xyz\tspam\x06\teggs')
def test_static(self):
alias = pyamf.register_class(Spam, 'abc.xyz')
alias.dynamic = False
x = Spam({'spam': 'eggs'})
self.encoder.writeElement(x)
self.assertEqual(self.buf.getvalue(), '\n\x03\x0fabc.xyz')
pyamf.unregister_class(Spam)
self.buf.truncate()
self.encoder.context.clear()
alias = pyamf.register_class(Spam, 'abc.xyz')
alias.dynamic = False
alias.static_attrs = ['spam']
x = Spam({'spam': 'eggs', 'foo': 'bar'})
self.encoder.writeElement(x)
self.assertEqual(self.buf.getvalue(), '\n\x13\x0fabc.xyz\tspam\x06\teggs')
def test_anonymous(self):
alias = ClassAlias(Spam, defer=True)
pyamf.CLASS_CACHE['foo'] = alias
pyamf.CLASS_CACHE[Spam] = alias
self.assertTrue(alias.anonymous)
ret = pyamf.unregister_class(Spam)
self.assertTrue('foo' in pyamf.CLASS_CACHE)
self.assertFalse(Spam in pyamf.CLASS_CACHE)
self.assertTrue(ret is alias)
def test_anonymous(self):
alias = ClassAlias(Spam, defer=True)
pyamf.CLASS_CACHE['foo'] = alias
pyamf.CLASS_CACHE[Spam] = alias
self.assertTrue(alias.anonymous)
ret = pyamf.unregister_class(Spam)
self.assertTrue('foo' in pyamf.CLASS_CACHE)
self.assertFalse(Spam in pyamf.CLASS_CACHE)
self.assertTrue(ret is alias)
def test_get_class_definition(self):
pyamf.register_class(Spam, 'abc.xyz')
x = Spam({'spam': 'eggs'})
class_def = self.encoder._getClassDefinition(x)
self.assertEquals(class_def.name, 'abc.xyz')
self.assertEquals(class_def.klass, Spam)
self.assertEquals(class_def.static_attrs, [])
pyamf.unregister_class(Spam)
# test anonymous object
x = {'spam': 'eggs'}
class_def = self.encoder._getClassDefinition(x)
self.assertEquals(class_def.name, '')
self.assertEquals(class_def.klass, pyamf.ASObject)
self.assertEquals(class_def.static_attrs, [])
def test_dynamic(self):
x = Spam()
x.foo = 'bar'
x.hello = 'world'
alias = pyamf.register_class(Spam)
alias.exclude_attrs = ['foo']
alias.compile()
self.assertTrue(alias.dynamic)
self._run([(x, '\x03\x00\x05hello\x02\x00\x05world\x00\x00\t')])
pyamf.unregister_class(Spam)
# try duplicate attributes
alias = pyamf.register_class(Spam)
alias.static_attrs = ['hello']
alias.compile()
self.assertTrue(alias.dynamic)
self._run([(x, '\x03\x00\x05hello\x02\x00\x05world\x00\x03foo\x02'
'\x00\x03bar\x00\x00\t')])
pyamf.unregister_class(Spam)
# and now typedobject
alias = pyamf.register_class(Spam, 'x')
alias.exclude_attrs = ['foo']
alias.compile()
self.assertTrue(alias.dynamic)
self._run([(x, '\x10\x00\x01x\x00\x05hello\x02\x00\x05world\x00\x00\t')
])
def test_dynamic(self):
x = Spam()
x.foo = 'bar'
x.hello = 'world'
alias = pyamf.register_class(Spam)
alias.exclude_attrs = ['foo']
alias.compile()
self.assertTrue(alias.dynamic)
self._run([(x, '\x03\x00\x05hello\x02\x00\x05world\x00\x00\t')])
pyamf.unregister_class(Spam)
# try duplicate attributes
alias = pyamf.register_class(Spam)
alias.static_attrs = ['hello']
alias.compile()
self.assertTrue(alias.dynamic)
self._run([(x, '\x03\x00\x05hello\x02\x00\x05world\x00\x03foo\x02'
'\x00\x03bar\x00\x00\t')])
pyamf.unregister_class(Spam)
# and now typedobject
alias = pyamf.register_class(Spam, 'x')
alias.exclude_attrs = ['foo']
alias.compile()
self.assertTrue(alias.dynamic)
self._run([(x,
'\x10\x00\x01x\x00\x05hello\x02\x00\x05world\x00\x00\t')])
def tearDown(self):
e.drop_all()
e.session.rollback()
e.session.expunge_all()
pyamf.unregister_class(Movie)
pyamf.unregister_class(Genre)
pyamf.unregister_class(Director)
def test_get_attrs(self):
pyamf.register_class(Spam)
alias = pyamf.get_class_alias(Spam)
x = Spam()
self.assertEquals(alias.getAttrs(x), (None, None))
pyamf.unregister_class(Spam)
pyamf.register_class(Spam, attrs=["foo"])
alias = pyamf.get_class_alias(Spam)
x = Spam()
self.assertEquals(alias.getAttrs(x), (["foo"], []))
pyamf.unregister_class(Spam)
pyamf.register_class(Spam, metadata=["dynamic"])
alias = pyamf.get_class_alias(Spam)
x = Spam()
self.assertEquals(alias.getAttrs(x), (None, None))
pyamf.unregister_class(Spam)
def af(x):
self.assertEquals(self._obj, x)
return ["bar"]
pyamf.register_class(Spam, attr_func=af, metadata=["dynamic"])
alias = pyamf.get_class_alias(Spam)
self._obj = Spam()
self.assertEquals(alias.getAttrs(self._obj), ([], ["bar"]))
pyamf.unregister_class(Spam)
def af(x):
self.assertEquals(self._obj, x)
return ["bar"]
pyamf.register_class(Spam, attrs=["foo", "bar"], attr_func=af, metadata=["dynamic"])
alias = pyamf.get_class_alias(Spam)
self._obj = Spam()
self.assertEquals(alias.getAttrs(self._obj), (["foo", "bar"], []))
def test_get_attrs(self):
pyamf.register_class(Spam)
alias = pyamf.get_class_alias(Spam)
x = Spam()
self.assertEquals(alias.getAttrs(x), None)
pyamf.unregister_class(Spam)
pyamf.register_class(Spam, attrs=['foo'])
alias = pyamf.get_class_alias(Spam)
x = Spam()
self.assertEquals(alias.getAttrs(x), ['foo'])
pyamf.unregister_class(Spam)
pyamf.register_class(Spam, metadata=['dynamic'])
alias = pyamf.get_class_alias(Spam)
x = Spam()
self.assertEquals(alias.getAttrs(x), None)
pyamf.unregister_class(Spam)
def af(x):
self.assertEquals(self._obj, x)
return ['bar']
pyamf.register_class(Spam, attr_func=af, metadata=['dynamic'])
alias = pyamf.get_class_alias(Spam)
self._obj = Spam()
self.assertEquals(alias.getAttrs(self._obj), ['bar'])
pyamf.unregister_class(Spam)
def af(x):
self.assertEquals(self._obj, x)
return ['bar']
pyamf.register_class(Spam, attrs=['foo', 'bar'], attr_func=af, metadata=['dynamic'])
alias = pyamf.get_class_alias(Spam)
self._obj = Spam()
self.assertEquals(alias.getAttrs(self._obj), ['foo', 'bar'])
def test_get_attrs(self):
pyamf.register_class(Spam)
alias = pyamf.get_class_alias(Spam)
x = Spam()
self.assertEquals(alias.getAttrs(x), None)
pyamf.unregister_class(Spam)
pyamf.register_class(Spam, attrs=['foo'])
alias = pyamf.get_class_alias(Spam)
x = Spam()
self.assertEquals(alias.getAttrs(x), ['foo'])
pyamf.unregister_class(Spam)
pyamf.register_class(Spam, metadata=['dynamic'])
alias = pyamf.get_class_alias(Spam)
x = Spam()
self.assertEquals(alias.getAttrs(x), None)
pyamf.unregister_class(Spam)
def af(x):
self.assertEquals(self._obj, x)
return ['bar']
pyamf.register_class(Spam, attr_func=af, metadata=['dynamic'])
alias = pyamf.get_class_alias(Spam)
self._obj = Spam()
self.assertEquals(alias.getAttrs(self._obj), ['bar'])
pyamf.unregister_class(Spam)
def af(x):
self.assertEquals(self._obj, x)
return ['bar']
pyamf.register_class(Spam, attrs=['foo', 'bar'], attr_func=af, metadata=['dynamic'])
alias = pyamf.get_class_alias(Spam)
self._obj = Spam()
self.assertEquals(alias.getAttrs(self._obj), ['foo', 'bar'])
def tearDown(self):
EncoderMixIn.tearDown(self)
pyamf.unregister_class(self.TestObject)
pyamf.unregister_class(self.TestSubObject)
def tearDown(self):
pyamf.unregister_class(builder.SomeClass)
pyamf.unregister_class(builder.SomeStaticClass)
del builder.SomeStaticClass.__amf__
def test_alias(self):
self.assertFalse('foo' in pyamf.CLASS_CACHE)
with self.assertRaises(pyamf.UnknownClassAlias):
pyamf.unregister_class('foo')
def tearDown(self):
pyamf.unregister_class(builder.SomeClass)
pyamf.unregister_class(builder.SomeStaticClass)
del builder.SomeStaticClass.__amf__
def tearDown(self):
EncoderMixIn.tearDown(self)
pyamf.unregister_class(self.TestObject)
pyamf.unregister_class(self.TestSubObject)
def test_alias(self):
alias = pyamf.register_class(Spam, "spam.eggs")
pyamf.unregister_class("spam.eggs")
self.assertTrue("spam.eggs" not in pyamf.CLASS_CACHE.keys())
self.assertTrue(alias not in pyamf.CLASS_CACHE)
class SmallCommandMsg(amfast_messaging.CommandMessage):
def __readamf__(self, data_input):
raise pyamf.EncodeError("__readamf__ is not implemented for this class: %s." % self)
def __writeamf__(self, data_output):
raise pyamf.EncodeError("__writeamf__ is not implemented for this class: %s." % self)
#----- Map Flex message classes with PyAmf -----#
# Clear existing message class mappings,
# then re-map with AmFast ClassDefs.
#---- AbstractMessage ---#
try:
pyamf.unregister_class('flex.messaging.messages.AbstractMessage')
except pyamf.UnknownClassAlias:
pass
register_class_def(class_def.ClassDef(amfast_messaging.AbstractMessage))
#---- AsyncMessage ----#
try:
pyamf.unregister_class('flex.messaging.messages.AsyncMessage')
except pyamf.UnknownClassAlias:
pass
try:
pyamf.unregister_class('DSA')
except pyamf.UnknownClassAlias:
pass
