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')