def test_deep(self):
class A(object):
pass
alias = miniamf.register_class(A, 'A')
alias.static_attrs = ['a']
class B(A):
pass
alias = miniamf.register_class(B, 'B')
alias.static_attrs = ['b']
class C(B):
pass
alias = miniamf.register_class(C, 'C')
alias.static_attrs = ['c']
x = C()
x.a = 'spam'
x.b = 'eggs'
x.c = 'foo'
self.assertEncoded(
x, b'\n;\x03C\x03a\x03b\x03c\x06\tspam\x06\teggs\x06\x07foo\x01')
def test_get_reference(self):
x = amf3.Context()
y = [1, 2, 3]
z = {'spam': 'eggs'}
spam_alias = miniamf.register_class(Spam, 'spam.eggs')
class Foo:
pass
foo_alias = miniamf.register_class(Foo, 'foo.bar')
a = amf3.ClassDefinition(spam_alias)
b = amf3.ClassDefinition(foo_alias)
ref1 = x.addObject(y)
ref2 = x.addObject(z)
x.addString(b'abc')
x.addString(b'def')
x.addClass(a, Spam)
x.addClass(b, Foo)
self.assertEqual(x.getObjectReference(y), ref1)
self.assertEqual(x.getObjectReference(z), ref2)
self.assertEqual(x.getObjectReference({}), -1)
self.assertEqual(x.getStringReference(b'abc'), 0)
self.assertEqual(x.getStringReference(b'def'), 1)
self.assertEqual(x.getStringReference(b'asdfas'), -1)
self.assertEqual(x.getClass(Spam), a)
self.assertEqual(x.getClass(Foo), b)
self.assertEqual(x.getClass(object()), None)
def test_dynamic(self):
miniamf.register_class(Spam, 'abc.xyz')
x = Spam({'spam': 'eggs'})
self.encoder.writeElement(x)
self.assertEqual(self.buf.getvalue(),
b'\n\x0b\x0fabc.xyz\tspam\x06\teggs\x01')
def test_classic_class(self):
miniamf.register_class(ClassicSpam, 'spam.eggs')
self.buf.append(
b'\x10\x00\tspam.eggs\x00\x03foo\x02\x00\x03bar\x00\x00\t')
foo = self.decoder.readElement()
self.assertEqual(foo.foo, 'bar')
def test_typed_object(self):
miniamf.register_class(Spam, alias='org.miniamf.spam')
x = Spam()
x.baz = 'hello'
self.assertEncoded(
x, b'\x10\x00\x10org.miniamf.spam'
b'\x00\x03baz\x02\x00\x05hello\x00\x00\t')
def test_anonymous(self):
miniamf.register_class(Spam)
x = Spam()
x.spam = 'eggs'
x.hello = 'world'
self.assertEncoded(x, b'\x03', (b'\x00\x05hello\x02\x00\x05world',
b'\x00\x04spam\x02\x00\x04eggs'),
b'\x00\x00\t')
def test_registered_alias(self):
class A:
pass
miniamf.register_class(A)
self.addCleanup(miniamf.unregister_class, A)
alias = self.context.getClassAlias(A)
self.assertTrue(isinstance(alias, miniamf.ClassAlias))
self.assertIdentical(alias.klass, A)
def test_registered_class(self):
miniamf.register_class(Spam, alias='org.miniamf.spam')
bytes = (
b'\x10\x00\x10org.miniamf.spam\x00\x03baz\x02\x00\x05hello\x00\x00'
b'\x09')
obj = self.decode(bytes)
self.assertEqual(type(obj), Spam)
self.assertTrue(hasattr(obj, 'baz'))
self.assertEqual(obj.baz, 'hello')
def test_nonexternal_subclassed_list(self):
class L(list):
pass
miniamf.register_class(L, 'a')
a = L()
a.append('foo')
a.append('bar')
self.assertEncoded(
a, b'\n\x00\x00\x00\x02\x02\x00\x03foo\x02\x00\x03bar')
def test_object(self):
self.assertEncoded({
'a': u'spam',
'b': 5
}, b'\n\x0b\x01\x03a\x06\tspam\x03b\x04\x05\x01')
miniamf.register_class(Spam, 'org.miniamf.spam')
obj = Spam()
obj.baz = 'hello'
self.assertEncoded(obj,
b'\n\x0b!org.miniamf.spam\x07baz\x06\x0bhello\x01')
def test_dynamic(self):
miniamf.register_class(Spam, 'abc.xyz')
self.buf.append(b'\x0a\x0b\x0fabc.xyz\x09spam\x06\x09eggs\x01')
obj = self.decoder.readElement()
class_def = self.context.getClass(Spam)
self.assertEqual(class_def.static_properties, [])
self.assertTrue(isinstance(obj, Spam))
self.assertEqual(obj.__dict__, {'spam': 'eggs'})
def test_object(self):
miniamf.register_class(Spam, 'org.miniamf.spam')
self.buf.truncate(0)
self.buf.seek(0, 0)
self.buf.append(
b'\x0a\x13!org.miniamf.spam\x07baz\x06\x0b\x68\x65\x6c\x6c\x6f')
obj = self.decoder.readElement()
self.assertEqual(obj.__class__, Spam)
self.assertTrue(hasattr(obj, 'baz'))
self.assertEqual(obj.baz, 'hello')
def test_slots_registered(self):
class Person(object):
__slots__ = ('family_name', 'given_name')
u = Person()
u.family_name = 'Doe'
u.given_name = 'Jane'
miniamf.register_class(Person, 'spam.eggs.Person')
self.assertEncoded(u, b'\x10\x00\x10spam.eggs.Person',
(b'\x00\x0bfamily_name\x02\x00\x03Doe',
b'\x00\ngiven_name\x02\x00\x04Jane'),
b'\x00\x00\t')
def test_slots_registered(self):
class Person(object):
__slots__ = ('family_name', 'given_name')
miniamf.register_class(Person, 'spam.eggs.Person')
u = Person()
u.family_name = 'Doe'
u.given_name = 'Jane'
self.assertEncoded(
u, b'\n\x0b!spam.eggs.Person',
(b'\x17family_name\x06\x07Doe', b'\x15given_name\x06\tJane'),
b'\x01')
def test_old_style_classes(self):
class Person:
pass
miniamf.register_class(Person, 'spam.eggs.Person')
u = Person()
u.family_name = 'Doe'
u.given_name = 'Jane'
self.assertEncoded(
u, b'\n\x0b!spam.eggs.Person',
(b'\x17family_name\x06\x07Doe', b'\x15given_name\x06\tJane'),
b'\x01')
def test_typed(self):
class XYZ(Exception):
pass
miniamf.register_class(XYZ, 'foo.bar')
try:
raise XYZ('blarg')
except Exception as e:
self.encoder.writeElement(e)
self.assertEqual(
self.buf.getvalue(), b'\n\x0b\x0ffoo.bar\x0f'
b'message\x06\x0bblarg\tname\x06\x07XYZ\x01')
def test_get_by_reference(self):
x = amf3.Context()
y = [1, 2, 3]
z = {'spam': 'eggs'}
alias_spam = miniamf.register_class(Spam, 'spam.eggs')
class Foo:
pass
class Bar:
pass
alias_foo = miniamf.register_class(Foo, 'foo.bar')
a = amf3.ClassDefinition(alias_spam)
b = amf3.ClassDefinition(alias_foo)
x.addObject(y)
x.addObject(z)
x.addString(b'abc')
x.addString(b'def')
x.addClass(a, Foo)
x.addClass(b, Bar)
self.assertEqual(x.getObject(0), y)
self.assertEqual(x.getObject(1), z)
self.assertEqual(x.getObject(2), None)
self.assertRaises(TypeError, x.getObject, '')
self.assertRaises(TypeError, x.getObject, 2.2323)
self.assertEqual(x.getString(0), b'abc')
self.assertEqual(x.getString(1), b'def')
self.assertEqual(x.getString(2), None)
self.assertRaises(TypeError, x.getString, b'')
self.assertRaises(TypeError, x.getString, 2.2323)
self.assertEqual(x.getClass(Foo), a)
self.assertEqual(x.getClass(Bar), b)
self.assertEqual(x.getClass(2), None)
self.assertEqual(x.getClassByReference(0), a)
self.assertEqual(x.getClassByReference(1), b)
self.assertEqual(x.getClassByReference(2), None)
self.assertEqual(x.getObject(2), None)
self.assertEqual(x.getString(2), None)
self.assertEqual(x.getClass(2), None)
self.assertEqual(x.getClassByReference(2), None)
def test_slots_registered(self):
class Person(object):
__slots__ = ('family_name', 'given_name')
miniamf.register_class(Person, 'spam.eggs.Person')
self.buf.append(
b'\x10\x00\x10spam.eggs.Person\x00\x0bfamily_name\x02\x00\x03Doe'
b'\x00\ngiven_name\x02\x00\x04Jane\x00\x00\t')
foo = self.decoder.readElement()
self.assertTrue(isinstance(foo, Person))
self.assertEqual(foo.family_name, 'Doe')
self.assertEqual(foo.given_name, 'Jane')
def test_typed(self):
class XYZ(Exception):
pass
miniamf.register_class(XYZ, 'foo.bar')
try:
raise XYZ('blarg')
except Exception as e:
self.encoder.writeElement(e)
self.assertEqual(
self.buffer.getvalue(),
b'\x10\x00\x07foo.bar\x00\x07message\x02\x00\x05blarg\x00\x04name'
b'\x02\x00\x03XYZ\x00\x00\t')
def test_static_attrs(self):
class Foo(object):
class __amf__:
static = ('foo', 'bar')
miniamf.register_class(Foo)
x = Foo()
x.foo = 'baz'
x.bar = 'gak'
self.assertEncoded(
x, b'\x03',
(b'\x00\x03bar\x02\x00\x03gak', b'\x00\x03foo\x02\x00\x03baz'),
b'\x00\x00\t')
def test_old_style_classes(self):
class Person:
pass
miniamf.register_class(Person, 'spam.eggs.Person')
u = Person()
u.family_name = 'Doe'
u.given_name = 'Jane'
self.encoder.writeElement(u)
self.assertEncoded(u, b'\x10\x00\x10spam.eggs.Person',
(b'\x00\x0bfamily_name\x02\x00\x03Doe',
b'\x00\ngiven_name\x02\x00\x04Jane'),
b'\x00\x00\t')
def test_slots(self):
class Person(object):
__slots__ = ('family_name', 'given_name')
miniamf.register_class(Person, 'spam.eggs.Person')
self.buf.append(
b'\n+!spam.eggs.Person\x17family_name\x15given_name\x06'
b'\x07Doe\x06\tJane\x02\x06\x06\x04\x06\x08\x01')
foo = self.decoder.readElement()
self.assertTrue(isinstance(foo, Person))
self.assertEqual(foo.family_name, 'Doe')
self.assertEqual(foo.given_name, 'Jane')
self.assertEqual(self.buf.remaining(), 0)
def test_force_amf3(self):
alias = miniamf.register_class(Spam, 'spam.eggs')
alias.amf3 = True
x = Spam()
x.x = 'y'
self.assertEncoded(x, b'\x11\n\x0b\x13spam.eggs\x03x\x06\x03y\x01')
def test_simple(self):
class A(object):
pass
alias = miniamf.register_class(A, 'A')
alias.static_attrs = ['a']
class B(A):
pass
alias = miniamf.register_class(B, 'B')
alias.static_attrs = ['b']
x = B()
x.a = 'spam'
x.b = 'eggs'
self.assertEncoded(x, b'\n+\x03B\x03a\x03b\x06\tspam\x06\teggs\x01')
def test_external(self):
alias = miniamf.register_class(Spam, 'abc.xyz')
alias.external = True
self.buf.append(b'\x0a\x07\x0fabc.xyz')
x = self.decoder.readElement()
self.assertTrue(isinstance(x, Spam))
self.assertEqual(x.__dict__, {})
def test_combined(self):
"""
This tests an object encoding with static properties and dynamic
properties
"""
miniamf.register_class(Spam, 'abc.xyz')
self.buf.append(
b'\x0a\x1b\x0fabc.xyz\x09spam\x06\x09eggs\x07baz\x06\x07nat\x01')
obj = self.decoder.readElement()
class_def = self.context.getClass(Spam)
self.assertEqual(class_def.static_properties, ['spam'])
self.assertTrue(isinstance(obj, Spam))
self.assertEqual(obj.__dict__, {'spam': 'eggs', 'baz': 'nat'})
def test_add_class(self):
x = amf3.Context()
alias = miniamf.register_class(Spam, 'spam.eggs')
y = amf3.ClassDefinition(alias)
self.assertEqual(x.addClass(y, Spam), 0)
self.assertEqual(x.classes, {Spam: y})
self.assertEqual(x.class_ref, {0: y})
self.assertEqual(len(x.class_ref), 1)
def test_external_subclassed_list(self):
class L(list):
class __amf__:
external = True
def __readamf__(self, o):
pass
def __writeamf__(self, o):
pass
miniamf.register_class(L, 'a')
a = L()
a.append('foo')
a.append('bar')
self.assertEncoded(a, b'\x10\x00\x01a\x00\x00\t')
def test_simple(self):
class A(object):
class __amf__:
static = ('a')
class B(A):
class __amf__:
static = ('b')
miniamf.register_class(A, 'A')
miniamf.register_class(B, 'B')
x = B()
x.a = 'spam'
x.b = 'eggs'
self.assertEncoded(
x, b'\x10\x00\x01B',
(b'\x00\x01a\x02\x00\x04spam', b'\x00\x01b\x02\x00\x04eggs'),
b'\x00\x00\t')
def test_combined(self):
alias = miniamf.register_class(Spam, 'abc.xyz')
alias.static_attrs = ['spam']
x = Spam({'spam': 'foo', 'eggs': 'bar'})
self.encoder.writeElement(x)
buf = self.buf.getvalue()
self.assertEqual(
buf, b'\n\x1b\x0fabc.xyz\tspam\x06\x07foo\teggs\x06\x07bar\x01')
