def test_expando(self):
# 'borrowed' from http://code.google.com/appengine/docs/datastore/entitiesandmodels.html
class Pet(db.Expando):
name = db.StringProperty(required=True)
type = db.StringProperty(required=True, choices=set(["cat", "dog", "bird"]))
birthdate = db.DateProperty()
weight_in_pounds = db.IntegerProperty()
spayed_or_neutered = db.BooleanProperty()
jessica = Pet(name='Jessica', type='cat')
jessica.birthdate = datetime.date(1986, 10, 2)
jessica.weight_in_pounds = 5
jessica.spayed_or_neutered = False
jessica.foo = 'bar'
encoder = pyamf.get_encoder(pyamf.AMF0)
encoder.writeElement(jessica)
self.assertEquals(encoder.stream.getvalue(),
'\x03\x00\x04name\x02\x00\x07Jessica\x00\tbirthdate\x0bB^\xc4\xae'
'\xaa\x00\x00\x00\x00\x00\x00\x10weight_in_pounds\x00@\x14\x00'
'\x00\x00\x00\x00\x00\x00\x03foo\x02\x00\x03bar\x00\x04type\x02'
'\x00\x03cat\x00\x12spayed_or_neutered\x01\x00\x00\x00\t')
encoder = pyamf.get_encoder(pyamf.AMF3)
encoder.writeElement(jessica)
self.assertEquals(encoder.stream.getvalue(),
'\n\x0b\x01\tname\x06\x0fJessica\x13birthdate\x08\x01B^\xc4\xae'
'\xaa\x00\x00\x00!weight_in_pounds\x04\x05\x07foo\x06\x07bar\t'
'type\x06\x07cat%spayed_or_neutered\x02\x01')
def test_expando(self):
# 'borrowed' from http://code.google.com/appengine/docs/datastore/entitiesandmodels.html
class Pet(db.Expando):
name = db.StringProperty(required=True)
type = db.StringProperty(required=True,
choices=set(["cat", "dog", "bird"]))
birthdate = db.DateProperty()
weight_in_pounds = db.IntegerProperty()
spayed_or_neutered = db.BooleanProperty()
jessica = Pet(name='Jessica', type='cat')
jessica.birthdate = datetime.date(1986, 10, 2)
jessica.weight_in_pounds = 5
jessica.spayed_or_neutered = False
jessica.foo = 'bar'
encoder = pyamf.get_encoder(pyamf.AMF0)
encoder.writeElement(jessica)
self.assertEquals(
encoder.stream.getvalue(),
'\x03\x00\x04name\x02\x00\x07Jessica\x00\tbirthdate\x0bB^\xc4\xae'
'\xaa\x00\x00\x00\x00\x00\x00\x10weight_in_pounds\x00@\x14\x00'
'\x00\x00\x00\x00\x00\x00\x03foo\x02\x00\x03bar\x00\x04type\x02'
'\x00\x03cat\x00\x12spayed_or_neutered\x01\x00\x00\x00\t')
encoder = pyamf.get_encoder(pyamf.AMF3)
encoder.writeElement(jessica)
self.assertEquals(
encoder.stream.getvalue(),
'\n\x0b\x01\tname\x06\x0fJessica\x13birthdate\x08\x01B^\xc4\xae'
'\xaa\x00\x00\x00!weight_in_pounds\x04\x05\x07foo\x06\x07bar\t'
'type\x06\x07cat%spayed_or_neutered\x02\x01')
def test_expando(self):
class Author(db.Expando):
name = db.StringProperty()
class Novel(db.Expando):
title = db.StringProperty()
author = db.ReferenceProperty(Author)
a = Author(name='Jane Austen')
a.put()
k = str(a.key())
b = Novel(title='Sense and Sensibility', author=a)
self.assertEquals(b.author, a)
try:
encoder = pyamf.get_encoder(pyamf.AMF0)
encoder.writeElement(b)
self.assertEquals(encoder.stream.getvalue(),
'\x03\x00\x04_key\x05\x00\x06author\x03\x00\x04_key\x02%s%s'
'\x00\x04name\x02\x00\x0bJane Austen\x00\x00\t\x00\x05title'
'\x02\x00\x15Sense and Sensibility\x00\x00\t' % (
struct.pack('>H', len(k)), k))
encoder = pyamf.get_encoder(pyamf.AMF3)
encoder.writeElement(b)
self.assertEquals(encoder.stream.getvalue(),
'\n;\x01\t_key\rauthor\x0btitle\x01\n+\x01\x00\tname\x06%s%s'
'\x06\x17Jane Austen\x01\x06+Sense and Sensibility\x01' % (
amf3._encode_int(len(k) << 1 | amf3.REFERENCE_BIT), k))
# now test with aliases ..
pyamf.register_class(Author, 'Author')
pyamf.register_class(Novel, 'Novel')
encoder = pyamf.get_encoder(pyamf.AMF0)
encoder.writeElement(b)
self.assertEquals(encoder.stream.getvalue(), '\x10\x00\x05Novel'
'\x00\x04_key\x05\x00\x06author\x10\x00\x06Author\x00\x04_key'
'\x02%s%s\x00\x04name\x02\x00\x0bJane Austen\x00\x00\t\x00'
'\x05title\x02\x00\x15Sense and Sensibility\x00\x00\t' % (
struct.pack('>H', len(k)), k))
encoder = pyamf.get_encoder(pyamf.AMF3)
encoder.writeElement(b)
self.assertEquals(encoder.stream.getvalue(),
'\n;\x0bNovel\t_key\rauthor\x0btitle\x01\n+\rAuthor\x02\tname'
'\x06%s%s\x06\x17Jane Austen\x01\x06+Sense and Sensibility'
'\x01' % (amf3._encode_int(len(k) << 1 | amf3.REFERENCE_BIT), k))
except:
a.delete()
raise
a.delete()
def test_objects_all(self):
encoder = pyamf.get_encoder(pyamf.AMF0)
encoder.writeElement(models.SimplestModel.objects.all())
self.assertEqual(encoder.stream.getvalue(), '\n\x00\x00\x00\x00')
encoder = pyamf.get_encoder(pyamf.AMF3)
encoder.writeElement(models.SimplestModel.objects.all())
self.assertEqual(encoder.stream.getvalue(), '\t\x01\x01')
def test_objects_all(self):
encoder = pyamf.get_encoder(pyamf.AMF0)
encoder.writeElement(models.SimplestModel.objects.all())
self.assertEqual(encoder.stream.getvalue(), '\n\x00\x00\x00\x00')
encoder = pyamf.get_encoder(pyamf.AMF3)
encoder.writeElement(models.SimplestModel.objects.all())
self.assertEqual(encoder.stream.getvalue(), '\t\x01\x01')
def test_expando(self):
class Author(db.Expando):
name = db.StringProperty()
class Novel(db.Expando):
title = db.StringProperty()
author = db.ReferenceProperty(Author)
a = Author(name='Jane Austen')
a.put()
k = str(a.key())
b = Novel(title='Sense and Sensibility', author=a)
self.assertEquals(b.author, a)
try:
encoder = pyamf.get_encoder(pyamf.AMF0)
encoder.writeElement(b)
self.assertEquals(encoder.stream.getvalue(),
'\x03\x00\x04_key\x05\x00\x06author\x03\x00\x04_key\x02%s%s'
'\x00\x04name\x02\x00\x0bJane Austen\x00\x00\t\x00\x05title'
'\x02\x00\x15Sense and Sensibility\x00\x00\t' % (
struct.pack('>H', len(k)), k))
encoder = pyamf.get_encoder(pyamf.AMF3)
encoder.writeElement(b)
self.assertEquals(encoder.stream.getvalue(),
'\n;\x01\t_key\rauthor\x0btitle\x01\n+\x01\x00\tname\x06%s%s'
'\x06\x17Jane Austen\x01\x06+Sense and Sensibility\x01' % (
amf3.encode_int(len(k) << 1 | amf3.REFERENCE_BIT), k))
# now test with aliases ..
pyamf.register_class(Author, 'Author')
pyamf.register_class(Novel, 'Novel')
encoder = pyamf.get_encoder(pyamf.AMF0)
encoder.writeElement(b)
self.assertEquals(encoder.stream.getvalue(), '\x10\x00\x05Novel'
'\x00\x04_key\x05\x00\x06author\x10\x00\x06Author\x00\x04_key'
'\x02%s%s\x00\x04name\x02\x00\x0bJane Austen\x00\x00\t\x00'
'\x05title\x02\x00\x15Sense and Sensibility\x00\x00\t' % (
struct.pack('>H', len(k)), k))
encoder = pyamf.get_encoder(pyamf.AMF3)
encoder.writeElement(b)
self.assertEquals(encoder.stream.getvalue(),
'\n;\x0bNovel\t_key\rauthor\x0btitle\x01\n+\rAuthor\x02\tname'
'\x06%s%s\x06\x17Jane Austen\x01\x06+Sense and Sensibility'
'\x01' % (amf3.encode_int(len(k) << 1 | amf3.REFERENCE_BIT), k))
finally:
a.delete()
def test_NOT_PROVIDED(self):
from django.db.models import fields
encoder = pyamf.get_encoder(pyamf.AMF0)
encoder.writeElement(fields.NOT_PROVIDED)
self.assertEquals(encoder.stream.getvalue(), '\x06')
encoder = pyamf.get_encoder(pyamf.AMF3)
encoder.writeElement(fields.NOT_PROVIDED)
self.assertEquals(encoder.stream.getvalue(), '\x00')
def test_NOT_PROVIDED(self):
from django.db.models import fields
encoder = pyamf.get_encoder(pyamf.AMF0)
encoder.writeElement(fields.NOT_PROVIDED)
self.assertEquals(encoder.stream.getvalue(), '\x06')
encoder = pyamf.get_encoder(pyamf.AMF3)
encoder.writeElement(fields.NOT_PROVIDED)
self.assertEquals(encoder.stream.getvalue(), '\x00')
def test_cached_reference_properties(self):
class Author(db.Model):
name = db.StringProperty()
class Novel(db.Model):
title = db.StringProperty()
author = db.ReferenceProperty(Author)
a = Author(name="Jane Austen")
a.put()
k = str(a.key())
b = Novel(title="Sense and Sensibility", author=a)
b.put()
c = Novel(title="Pride and Prejudice", author=a)
c.put()
try:
s, p = Novel.all().order("-title").fetch(2)
encoder = pyamf.get_encoder(pyamf.AMF3)
stream = encoder.stream
context = encoder.context
self.assertFalse(hasattr(context, "gae_objects"))
encoder.writeElement(s)
self.assertTrue(hasattr(context, "gae_objects"))
self.assertEquals(context.gae_objects, {Novel: {str(s.key()): s}, Author: {k: a}})
encoder.writeElement(p)
self.assertEquals(context.gae_objects, {Novel: {str(s.key()): s, str(p.key()): p}, Author: {k: a}})
finally:
a.delete()
b.delete()
c.delete()
c = Novel(title="Pride and Prejudice", author=None)
c.put()
encoder = pyamf.get_encoder(encoding=pyamf.AMF3)
alias = adapter_db.DataStoreClassAlias(Novel, None)
self.assertEquals(
alias.getAttributes(c, codec=encoder),
({"_key": str(c.key()), "title": "Pride and Prejudice", "author": None}, {}),
)
def test_objects_all(self):
from django.db import models
class Spam(models.Model):
pass
self.resetDB()
encoder = pyamf.get_encoder(pyamf.AMF0)
encoder.writeElement(Spam.objects.all())
self.assertEquals(encoder.stream.getvalue(), '\n\x00\x00\x00\x00')
encoder = pyamf.get_encoder(pyamf.AMF3)
encoder.writeElement(Spam.objects.all())
self.assertEquals(encoder.stream.getvalue(), '\t\x01\x01')
def pyamfEncode(self, obj, amf3=False, use_proxies=False):
if amf3 is True:
context = pyamf.get_context(pyamf.AMF3)
else:
context = pyamf.get_context(pyamf.AMF0)
stream = BufferedByteStream()
if amf3 is True:
pyamf_encoder = pyamf.get_encoder(pyamf.AMF3, stream=stream, context=context)
else:
pyamf_encoder = pyamf.get_encoder(pyamf.AMF0, stream=stream, context=context)
pyamf_encoder.writeElement(obj)
return pyamf_encoder.stream.getvalue()
def test_objects_all(self):
from django.db import models
class Spam(models.Model):
pass
self.resetDB()
encoder = pyamf.get_encoder(pyamf.AMF0)
encoder.writeElement(Spam.objects.all())
self.assertEquals(encoder.stream.getvalue(), '\n\x00\x00\x00\x00')
encoder = pyamf.get_encoder(pyamf.AMF3)
encoder.writeElement(Spam.objects.all())
self.assertEquals(encoder.stream.getvalue(), '\t\x01\x01')
def test_objects_all(self):
class Spam(models.Model):
pass
cursor = connection.cursor()
cursor.execute('CREATE TABLE gateway_spam (id INTEGER PRIMARY KEY)')
encoder = pyamf.get_encoder(pyamf.AMF0)
encoder.writeElement(Spam.objects.all())
self.assertEquals(encoder.stream.getvalue(), '\n\x00\x00\x00\x00')
encoder = pyamf.get_encoder(pyamf.AMF3)
encoder.writeElement(Spam.objects.all())
self.assertEquals(encoder.stream.getvalue(), '\t\x01\x01')
cursor.execute('DROP TABLE gateway_spam')
def test_amf3(self):
encoder = pyamf.get_encoder(pyamf.AMF3)
context = encoder.context
stream = encoder.stream
s = str(self.jessica.key())
self.assertFalse(hasattr(context, 'gae_objects'))
encoder.writeObject(self.jessica)
self.assertTrue(hasattr(context, 'gae_objects'))
self.assertEquals(context.gae_objects, {PetModel: {s: self.jessica}})
self.assertEquals(
stream.getvalue(), '\nk\x01\t_key!weight_in_pounds'
'\ttype\tname\x13birthdate%%spayed_or_neutered\x06%s%s\x04\x05\x06'
'\x07cat\x06\x0fJessica\x08\x01B^\xc4\xae\xaa'
'\x00\x00\x00\x02\x01' %
(amf3._encode_int(len(s) << 1 | amf3.REFERENCE_BIT), s))
stream.truncate()
encoder.writeObject(self.jessica2)
self.assertTrue(hasattr(context, 'gae_objects'))
self.assertEquals(context.gae_objects, {PetModel: {s: self.jessica}})
self.assertEquals(stream.getvalue(), '\n\x00')
def test_proxy(self):
from pyamf import flex
c = pyamf.get_encoder(pyamf.AMF3)
self.alias.proxy_attrs = ('foo', 'bar')
self.alias.compile()
self.assertEqual(self.alias.proxy_attrs, ['bar', 'foo'])
self.obj.foo = ['bar', 'baz']
self.obj.bar = {'foo': 'gak'}
attrs = self.alias.getEncodableAttributes(self.obj, c)
k = list(attrs.keys())
k.sort()
self.assertEqual(k, ['bar', 'foo'])
self.assertTrue(isinstance(attrs['foo'], flex.ArrayCollection))
self.assertEqual(attrs['foo'], ['bar', 'baz'])
self.assertTrue(isinstance(attrs['bar'], flex.ObjectProxy))
self.assertEqual(attrs['bar']._amf_object, {'foo': 'gak'})
def test_amf0(self):
encoder = pyamf.get_encoder(pyamf.AMF0)
context = encoder.context
stream = encoder.stream
s = str(self.jessica.key())
self.assertFalse(hasattr(context, 'gae_objects'))
encoder.writeObject(self.jessica)
self.assertTrue(hasattr(context, 'gae_objects'))
self.assertEquals(context.gae_objects, {PetModel: {s: self.jessica}})
self.assertEquals(stream.getvalue(), '\x03\x00\x04_key\x02%s%s\x00'
'\tbirthdate\x0bB^\xc4\xae\xaa\x00\x00\x00\x00\x00\x00\x04name'
'\x02\x00\x07Jessica\x00\x12spayed_or_neutered\x01\x00\x00\x04'
'type\x02\x00\x03cat\x00\x10weight_in_pounds\x00@\x14\x00\x00\x00'
'\x00\x00\x00\x00\x00\t' % (struct.pack('>H', len(s)), s))
stream.truncate()
encoder.writeObject(self.jessica2)
self.assertTrue(hasattr(context, 'gae_objects'))
self.assertEquals(context.gae_objects, {PetModel: {s: self.jessica}})
self.assertEquals(stream.getvalue(), '\x07\x00\x00')
stream.truncate()
# check a non referenced object
toby = PetModel(name='Toby', type='cat')
toby.put()
try:
encoder.writeObject(toby)
finally:
toby.delete()
def test_proxy(self):
from pyamf import flex
c = pyamf.get_encoder(pyamf.AMF3)
self.alias.proxy_attrs = ('foo', 'bar')
self.alias.compile()
self.assertEqual(self.alias.proxy_attrs, ['bar', 'foo'])
self.obj.foo = ['bar', 'baz']
self.obj.bar = {'foo': 'gak'}
attrs = self.alias.getEncodableAttributes(self.obj, c)
k = attrs.keys()
k.sort()
self.assertEqual(k, ['bar', 'foo'])
self.assertTrue(isinstance(attrs['foo'], flex.ArrayCollection))
self.assertEqual(attrs['foo'], ['bar', 'baz'])
self.assertTrue(isinstance(attrs['bar'], flex.ObjectProxy))
self.assertEqual(attrs['bar']._amf_object, {'foo': 'gak'})
def __init__( self ):
# Prepare the encoder and decoder
self.encoder = pyamf.get_encoder( self.encoding )
self.ostream = self.encoder.stream
self.decoder = pyamf.get_decoder( self.encoding )
self.istream = self.decoder.stream
self.ipos = 0
def test_amf3(self):
encoder = pyamf.get_encoder(pyamf.AMF3)
encoder.writeElement(self.jessica)
self.assertEquals(encoder.stream.getvalue(),
'\nk\x01\t_key\x13birthdate\tname%spayed_or_neutered\ttype!'
'weight_in_pounds\x01\x08\x01B^\xc4\xae\xaa\x00\x00\x00\x06\x0f'
'Jessica\x02\x06\x07cat\x04\x05\x01')
def test_amf3(self):
encoder = pyamf.get_encoder(pyamf.AMF3)
context = encoder.context
stream = encoder.stream
s = str(self.jessica.key())
self.assertFalse(hasattr(context, "gae_objects"))
encoder.writeObject(self.jessica)
self.assertTrue(hasattr(context, "gae_objects"))
self.assertEquals(context.gae_objects, {PetModel: {s: self.jessica}})
self.assertEquals(
stream.getvalue(),
"\nk\x01\t_key!weight_in_pounds"
"\ttype\tname\x13birthdate%%spayed_or_neutered\x06%s%s\x04\x05\x06"
"\x07cat\x06\x0fJessica\x08\x01B^\xc4\xae\xaa"
"\x00\x00\x00\x02\x01" % (amf3._encode_int(len(s) << 1 | amf3.REFERENCE_BIT), s),
)
stream.truncate()
encoder.writeObject(self.jessica2)
self.assertTrue(hasattr(context, "gae_objects"))
self.assertEquals(context.gae_objects, {PetModel: {s: self.jessica}})
self.assertEquals(stream.getvalue(), "\n\x00")
def send(self, message):
self.sends.append(message)
# tell server we started listening
logging.debug('send: request: %s' % message.__repr__())
encoder = pyamf.get_encoder(object_encoding)
encoder.writeElement(message)
message = encoder.stream.getvalue()
encoder.stream.truncate()
logging.debug('send: encoded request: %s' % message.__repr__())
send_log = encoder.stream.tell().__repr__() \
+ encoder.stream.__repr__()
logging.debug('send; ' + send_log)
decoder = pyamf.get_decoder(object_encoding, message)
#if not isinstance(stream, util.BufferedByteStream):
# stream = util.BufferedByteStream(stream)
logging.debug('send: '
+ decoder.stream.tell().__repr__()
+ decoder.stream.__repr__())
data = decoder.readElement()
logging.debug('send: decoded %s' % data.__repr__())
try:
#total_sent = 0
#while total_sent < len(message):
sent = self.sock.send(message)
if sent == 0:
raise RuntimeError, \
"socket connection broken"
# total_sent += sent
except socket.error, e:
raise Exception("Can't connect: %s" % e[1])
def test_amf3(self):
encoder = pyamf.get_encoder(pyamf.AMF3)
encoder.writeElement(self.jessica)
self.assertEquals(encoder.stream.getvalue(),
'\n[\x01!weight_in_pounds\ttype\tname\x13birthdate%'
'spayed_or_neutered\x04\x05\x06\x07cat\x06\x0fJessica\x08\x01B^'
'\xc4\xae\xaa\x00\x00\x00\x02\x07foo\x06\x07bar\x01')
def __init__(self):
self.started = False
self.encoder = pyamf.get_encoder(self.encoding)
self.stream = self.encoder.stream
self.context= self.encoder.context
pyamf.register_class(Screen, "Screen")
amf3.use_proxies_default = True
def _amf3_encoder(self):
encoder = getattr(self, "__amf3_encoder", None)
if not encoder:
encoder = pyamf.get_encoder(pyamf.AMF3, stream=self.stream, timezone_offset=self.timezone_offset)
self.__amf3_encoder = encoder
return encoder
def test_pure_encoder(self):
"""
With `use_ext=False` specified, the extension must NOT be returned.
"""
from pyamf import amf3
encoder = pyamf.get_encoder(pyamf.AMF3, use_ext=False)
self.assertIsInstance(encoder, amf3.Encoder)
def test_amf0(self):
encoder = pyamf.get_encoder(pyamf.AMF0)
encoder.writeElement(self.jessica)
self.assertEquals(encoder.stream.getvalue(),
'\x03\x00\x10weight_in_pounds\x00@\x14\x00\x00\x00\x00\x00\x00'
'\x00\x04name\x02\x00\x07Jessica\x00\x03foo\x02\x00\x03bar\x00'
'\x04type\x02\x00\x03cat\x00\tbirthdate\x0bB^\xc4\xae\xaa\x00\x00'
'\x00\x00\x00\x00\x12spayed_or_neutered\x01\x00\x00\x00\t')
def test_amf3(self):
encoder = pyamf.get_encoder(pyamf.AMF3)
encoder.writeElement(self.jessica)
self.assertEquals(
encoder.stream.getvalue(),
'\n[\x01!weight_in_pounds\ttype\tname\x13birthdate%'
'spayed_or_neutered\x04\x05\x06\x07cat\x06\x0fJessica\x08\x01B^'
'\xc4\xae\xaa\x00\x00\x00\x02\x07foo\x06\x07bar\x01')
def test_alias_amf3(self):
pyamf.register_class(PetExpando, 'Pet')
encoder = pyamf.get_encoder(pyamf.AMF3)
encoder.writeElement(self.jessica)
self.assertEquals(encoder.stream.getvalue(),
'\nk\x07Pet\t_key!weight_in_pounds\ttype\tname\x13birthdate%'
'spayed_or_neutered\x01\x04\x05\x06\x07cat\x06\x0fJessica\x08\x01'
'B^\xc4\xae\xaa\x00\x00\x00\x02\x07foo\x06\x07bar\x01')
def __init__(self, on_receive = None, minimum_interval = minimum_interval):
self.socket = simple_socket.socket_class()
self.sends = []
self.receives = []
self.is_alive = None
self.encoder = pyamf.get_encoder(object_encoding)
self.on_receive = on_receive
self.receive_time = None
self.minimum_interval = minimum_interval
def test_encode(self):
encoder = pyamf.get_encoder(pyamf.AMF0)
decoder = pyamf.get_decoder(pyamf.AMF0)
decoder.stream = encoder.stream
try:
raise TypeError, "unknown type"
except TypeError, e:
encoder.writeElement(amf0.build_fault(*sys.exc_info()))
def _amf3_encoder(self):
encoder = getattr(self, '__amf3_encoder', None)
if not encoder:
encoder = pyamf.get_encoder(pyamf.AMF3, stream=self.stream,
timezone_offset=self.timezone_offset)
self.__amf3_encoder = encoder
return encoder
def test_encode_amf0(self):
self.encoder = pyamf.get_encoder(pyamf.AMF0)
self.buf = self.encoder.stream
x = flex.ArrayCollection()
x.append('eggs')
self.assertEncoded(x,
'\x11\n\x07Cflex.messaging.io.ArrayCollection\t\x03\x01\x06\teggs')
def test_encode_decode_transient(self):
user = self._build_obj()
encoder = pyamf.get_encoder(pyamf.AMF3)
encoder.writeElement(user)
encoded = encoder.stream.getvalue()
decoded = pyamf.get_decoder(pyamf.AMF3, encoded).readElement()
self._test_obj(user, decoded)
def test_encode(self):
encoder = pyamf.get_encoder(pyamf.AMF0)
decoder = pyamf.get_decoder(pyamf.AMF0)
decoder.stream = encoder.stream
try:
raise TypeError("Unknown type")
except TypeError, e:
encoder.writeElement(amf0.build_fault(*sys.exc_info()))
def test_pure_encoder(self):
"""
With `use_ext=False` specified, the extension must NOT be returned.
"""
from pyamf import amf3
encoder = pyamf.get_encoder(pyamf.AMF3, use_ext=False)
self.assertIsInstance(encoder, amf3.Encoder)
def test_encode(self):
obj = ListModel()
obj.numbers = [2, 4, 6, 8, 10]
encoder = pyamf.get_encoder(pyamf.AMF0)
encoder.writeElement(obj)
self.assertEquals(
encoder.stream.getvalue(),
"\x03\x00\x04_key\x05\x00\x07numbers\n\x00\x00\x00\x05\x00@"
"\x00\x00\x00\x00\x00\x00\x00\x00@\x10\x00\x00\x00\x00\x00\x00"
"\x00@\x18\x00\x00\x00\x00\x00\x00\x00@ \x00\x00\x00\x00\x00\x00"
"\x00@$\x00\x00\x00\x00\x00\x00\x00\x00\t",
)
encoder = pyamf.get_encoder(pyamf.AMF3)
encoder.writeElement(obj)
self.assertEquals(
encoder.stream.getvalue(),
"\n+\x01\t_key\x0fnumbers\x01\t\x0b\x01\x04\x02\x04\x04\x04\x06" "\x04\x08\x04\n\x01",
)
pyamf.register_class(ListModel, "list-model")
encoder = pyamf.get_encoder(pyamf.AMF0)
encoder.writeElement(obj)
self.assertEquals(
encoder.stream.getvalue(),
"\x10\x00\nlist-model\x00\x04_key\x05\x00\x07numbers\n\x00\x00"
"\x00\x05\x00@\x00\x00\x00\x00\x00\x00\x00\x00@\x10\x00\x00\x00"
"\x00\x00\x00\x00@\x18\x00\x00\x00\x00\x00\x00\x00@ \x00\x00\x00"
"\x00\x00\x00\x00@$\x00\x00\x00\x00\x00\x00\x00\x00\t",
)
encoder = pyamf.get_encoder(pyamf.AMF3)
encoder.writeElement(obj)
self.assertEquals(
encoder.stream.getvalue(),
"\n+\x15list-model\t_key\x0fnumbers\x01\t\x0b\x01\x04\x02\x04\x04" "\x04\x06\x04\x08\x04\n\x01",
)
def test_alias_amf3(self):
pyamf.register_class(PetExpando, 'Pet')
encoder = pyamf.get_encoder(pyamf.AMF3)
encoder.writeElement(self.jessica)
self.assertEquals(
encoder.stream.getvalue(),
'\nk\x07Pet\t_key!weight_in_pounds\ttype\tname\x13birthdate%'
'spayed_or_neutered\x01\x04\x05\x06\x07cat\x06\x0fJessica\x08\x01'
'B^\xc4\xae\xaa\x00\x00\x00\x02\x07foo\x06\x07bar\x01')
def test_amf3(self):
encoder = pyamf.get_encoder(pyamf.AMF3)
stream = encoder.stream
encoder.writeElement(self.jessica)
stream.truncate()
encoder.writeElement(self.jessica2)
self.assertEqual(stream.getvalue(), '\n\x00')
def test_amf0(self):
encoder = pyamf.get_encoder(pyamf.AMF0)
encoder.writeElement(self.jessica)
self.assertEquals(encoder.stream.getvalue(),
'\x03\x00\x04_key\x05\x00\tbirthdate\x0bB^\xc4\xae\xaa\x00\x00'
'\x00\x00\x00\x00\x04name\x02\x00\x07Jessica\x00\x12'
'spayed_or_neutered\x01\x00\x00\x04type\x02\x00\x03cat\x00\x10'
'weight_in_pounds\x00@\x14\x00\x00\x00\x00\x00\x00\x00\x03foo\x02'
'\x00\x03bar\x00\x00\t')
def pyamfEncode(self, obj, amf3=False, use_proxies=False):
if amf3 is True:
context = pyamf.get_context(pyamf.AMF3)
else:
context = pyamf.get_context(pyamf.AMF0)
stream = BufferedByteStream()
if amf3 is True:
pyamf_encoder = pyamf.get_encoder(pyamf.AMF3,
stream=stream,
context=context)
else:
pyamf_encoder = pyamf.get_encoder(pyamf.AMF0,
stream=stream,
context=context)
pyamf_encoder.writeElement(obj)
return pyamf_encoder.stream.getvalue()
def test_alias_amf0(self):
pyamf.register_class(PetModel, 'Pet')
encoder = pyamf.get_encoder(pyamf.AMF0)
encoder.writeElement(self.jessica)
self.assertEquals(encoder.stream.getvalue(),
'\x10\x00\x03Pet\x00\x04_key\x05\x00\tbirthdate\x0bB^\xc4\xae\xaa'
'\x00\x00\x00\x00\x00\x00\x04name\x02\x00\x07Jessica\x00\x12'
'spayed_or_neutered\x01\x00\x00\x04type\x02\x00\x03cat\x00\x10'
'weight_in_pounds\x00@\x14\x00\x00\x00\x00\x00\x00\x00\x00\t')
def test_amf3(self):
encoder = pyamf.get_encoder(pyamf.AMF3)
stream = encoder.stream
encoder.writeElement(self.jessica)
stream.truncate()
encoder.writeElement(self.jessica2)
self.assertEqual(stream.getvalue(), '\n\x00')
def test_nullreference(self):
c = models.Novel(title="Pride and Prejudice", author=None)
c.put()
encoder = pyamf.get_encoder(encoding=pyamf.AMF3)
alias = adapter.DataStoreClassAlias(models.Novel, None)
attrs = alias.getEncodableAttributes(c, codec=encoder)
self.assertEqual(attrs, {"_key": str(c.key()), "title": "Pride and Prejudice", "author": None})
def encode(self, buf):
"""
Encode a notification message.
"""
args = [self.name, self.id] + self.argv
encoder = pyamf.get_encoder(self.encoding, buf)
for a in args:
encoder.writeElement(a)
def encode(self, buf):
"""
Encode a notification message.
"""
args = [self.name, self.id] + self.argv
encoder = pyamf.get_encoder(self.encoding, buf)
for a in args:
encoder.writeElement(a)
def test_encode_amf0(self):
self.encoder = pyamf.get_encoder(pyamf.AMF0)
self.buf = self.encoder.stream
x = flex.ArrayCollection()
x.append('eggs')
self.assertEncoded(
x,
'\x11\n\x07Cflex.messaging.io.ArrayCollection\t\x03\x01\x06\teggs')
def encode(msg, strict=False, logger=None, timezone_offset=None, **kwargs):
"""
Encodes and returns the L{msg<Envelope>} as an AMF stream.
@param strict: Enforce strict encoding. Default is C{False}. Specifically
header/body lengths will be written correctly, instead of the default
0. Default is C{False}. Introduced in 0.4.
@type strict: C{boolean}
@param logger: Used to log interesting events whilst decoding a remoting
message.
@type logger: U{logging.Logger<http://
docs.python.org/library/logging.html#loggers>}
@param timezone_offset: The difference between the current timezone and
UTC. Date/times should always be handled in UTC to avoid confusion but
this is required for legacy systems.
@type timezone_offset: U{datetime.datetime.timedelta<http://
docs.python.org/library/datetime.html#datetime.timedelta>}
@rtype: L{BufferedByteStream<pyamf.util.BufferedByteStream>}
"""
stream = util.BufferedByteStream()
encoder = pyamf.get_encoder(
pyamf.AMF0,
stream,
strict=strict,
timezone_offset=timezone_offset,
**kwargs
)
if msg.amfVersion == pyamf.AMF3:
encoder.use_amf3 = True
stream.write_ushort(msg.amfVersion)
stream.write_ushort(len(msg.headers))
for name, header in msg.headers.iteritems():
_write_header(
name,
header,
int(msg.headers.is_required(name)),
stream,
encoder,
strict,
)
stream.write_short(len(msg))
for name, message in msg.iteritems():
encoder.context.clear()
_write_body(name, message, stream, encoder, strict)
stream.seek(0)
return stream
def getAMF3Encoder(self, amf0_encoder):
encoder = self.extra.get('amf3_encoder', None)
if encoder:
return encoder
encoder = pyamf.get_encoder(pyamf.AMF3, stream=amf0_encoder.stream,
timezone_offset=amf0_encoder.timezone_offset)
self.extra['amf3_encoder'] = encoder
return encoder
def encode(msg, strict=False, logger=None, timezone_offset=None):
"""
Encodes and returns the L{msg<Envelope>} as an AMF stream.
@param strict: Enforce strict encoding. Default is C{False}. Specifically
header/body lengths will be written correctly, instead of the default
0. Default is C{False}. Introduced in 0.4.
@type strict: C{boolean}
@param logger: Used to log interesting events whilst decoding a remoting
message.
@type logger: U{logging.Logger<http://
docs.python.org/library/logging.html#loggers>}
@param timezone_offset: The difference between the current timezone and
UTC. Date/times should always be handled in UTC to avoid confusion but
this is required for legacy systems.
@type timezone_offset: U{datetime.datetime.timedelta<http://
docs.python.org/library/datetime.html#datetime.timedelta>}
@rtype: L{BufferedByteStream<pyamf.util.BufferedByteStream>}
"""
stream = util.BufferedByteStream()
encoder = pyamf.get_encoder(
pyamf.AMF0,
stream,
strict=strict,
timezone_offset=timezone_offset,
)
if msg.amfVersion == pyamf.AMF3:
encoder.use_amf3 = True
stream.write_ushort(msg.amfVersion)
stream.write_ushort(len(msg.headers))
for name, header in msg.headers.iteritems():
_write_header(
name,
header,
int(msg.headers.is_required(name)),
stream,
encoder,
strict,
)
stream.write_short(len(msg))
for name, message in msg.iteritems():
encoder.context.clear()
_write_body(name, message, stream, encoder, strict)
stream.seek(0)
return stream
def test_get_encoder(self):
from pyamf import amf0, amf3
self.assertEquals(pyamf._get_encoder_class(pyamf.AMF0), amf0.Encoder)
self.assertEquals(pyamf._get_encoder_class(pyamf.AMF3), amf3.Encoder)
self.assertRaises(ValueError, pyamf._get_encoder_class, 'spam')
self.assertTrue(isinstance(pyamf.get_encoder(pyamf.AMF0), amf0.Encoder))
self.assertTrue(isinstance(pyamf.get_encoder(pyamf.AMF3), amf3.Encoder))
self.assertRaises(ValueError, pyamf.get_encoder, 'spam')
context = amf0.Context()
encoder = pyamf.get_encoder(pyamf.AMF0, data='spam', context=context)
self.assertEquals(encoder.stream.getvalue(), 'spam')
self.assertEquals(encoder.context, context)
context = amf3.Context()
encoder = pyamf.get_encoder(pyamf.AMF3, data='eggs', context=context)
self.assertEquals(encoder.stream.getvalue(), 'eggs')
self.assertEquals(encoder.context, context)
def test_encode(self):
obj = ListModel()
obj.numbers = [2, 4, 6, 8, 10]
encoder = pyamf.get_encoder(pyamf.AMF0)
encoder.writeElement(obj)
self.assertEquals(
encoder.stream.getvalue(),
'\x03\x00\x07numbers\n\x00\x00\x00\x05\x00@\x00\x00\x00\x00\x00'
'\x00\x00\x00@\x10\x00\x00\x00\x00\x00\x00\x00@\x18\x00\x00\x00'
'\x00\x00\x00\x00@ \x00\x00\x00\x00\x00\x00\x00@$\x00\x00\x00\x00'
'\x00\x00\x00\x00\t')
encoder = pyamf.get_encoder(pyamf.AMF3)
encoder.writeElement(obj)
self.assertEquals(
encoder.stream.getvalue(),
'\n\x1b\x01\x0fnumbers\t\x0b\x01\x04\x02\x04\x04\x04\x06\x04\x08'
'\x04\n\x01')
pyamf.register_class(ListModel, 'list-model')
encoder = pyamf.get_encoder(pyamf.AMF0)
encoder.writeElement(obj)
self.assertEquals(
encoder.stream.getvalue(),
'\x10\x00\nlist-model\x00\x07numbers\n\x00\x00\x00\x05\x00@\x00'
'\x00\x00\x00\x00\x00\x00\x00@\x10\x00\x00\x00\x00\x00\x00\x00@'
'\x18\x00\x00\x00\x00\x00\x00\x00@ \x00\x00\x00\x00\x00\x00\x00@$'
'\x00\x00\x00\x00\x00\x00\x00\x00\t')
encoder = pyamf.get_encoder(pyamf.AMF3)
encoder.writeElement(obj)
self.assertEquals(
encoder.stream.getvalue(),
'\n\x1b\x15list-model\x0fnumbers\t\x0b\x01\x04\x02\x04\x04\x04'
'\x06\x04\x08\x04\n\x01')
def test_save_amf3(self):
self.jessica.put()
k = str(self.jessica.key())
encoder = pyamf.get_encoder(pyamf.AMF3)
encoder.writeElement(self.jessica)
self.assertEquals(encoder.stream.getvalue(),
'\nk\x01\t_key\x13birthdate\tname%%spayed_or_neutered\ttype!'
'weight_in_pounds\x06%s%s\x08\x01B^\xc4\xae\xaa\x00\x00\x00\x06'
'\x0fJessica\x02\x06\x07cat\x04\x05\x01' % (
amf3.encode_int(len(k) << 1 | amf3.REFERENCE_BIT), k))
def test_ext_encoder(self):
"""
With `use_ext=True` specified, the extension must be returned.
"""
try:
from cpyamf import amf3
except ImportError:
self.skipTest('amf3 extension not available')
encoder = pyamf.get_encoder(pyamf.AMF3, use_ext=True)
self.assertIsInstance(encoder, amf3.Encoder)
def test_default_encoder(self):
"""
If the extension is available, it must be returned by default.
"""
try:
from cpyamf import amf3
except ImportError:
from pyamf import amf3
encoder = pyamf.get_encoder(pyamf.AMF3)
self.assertIsInstance(encoder, amf3.Encoder)
def encode(msg, context=None, strict=False, logger=None, timezone_offset=None):
"""
Encodes AMF stream and returns file object.
@type msg: L{Envelope}
@param msg: The message to encode.
@type strict: C{bool}
@param strict: Determines whether encoding should be strict. Specifically
header/body lengths will be written correctly, instead of the default 0.
Default is C{False}. Introduced in 0.4.
@param logger: Used to log interesting events whilst encoding a remoting
message.
@type logger: A L{logging.Logger} instance or C{None}.
@param timezone_offset: The difference between the current timezone and
UTC. Date/times should always be handled in UTC to avoid confusion but
this is required for legacy systems.
@type timezone_offset: L{datetime.timedelta}
@rtype: C{StringIO}
@return: File object.
"""
stream = util.BufferedByteStream()
if context is None:
context = pyamf.get_context(pyamf.AMF0, exceptions=False)
encoder = pyamf.get_encoder(pyamf.AMF0,
stream,
context=context,
timezone_offset=timezone_offset,
strict=strict)
if msg.clientType == pyamf.ClientTypes.Flash9:
encoder.use_amf3 = True
stream.write_uchar(msg.amfVersion)
stream.write_uchar(msg.clientType)
stream.write_short(len(msg.headers))
for name, header in msg.headers.iteritems():
_write_header(name, header, int(msg.headers.is_required(name)), stream,
encoder, strict)
stream.write_short(len(msg))
for name, message in msg.iteritems():
encoder.context.clear()
_write_body(name, message, stream, encoder, strict)
stream.seek(0)
return stream
def encode(name, values, strict=True, encoding=pyamf.AMF0):
"""
Produces a SharedObject encoded stream based on the name and values.
@param name: The root name of the SharedObject.
@type name: C{basestring}
@param values: A C{dict} of name value pairs to be encoded in the stream.
@type values: C{dict}
@param strict: Ensure that the SOL stream is as spec compatible as possible.
@type strict: C{bool}
@return: A SharedObject encoded stream.
@rtype: L{BufferedByteStream<pyamf.util.BufferedByteStream>}
"""
encoder = pyamf.get_encoder(encoding)
encoder.stream = stream = util.BufferedByteStream()
# write the header
stream.write(HEADER_VERSION)
if strict is True:
length_pos = stream.tell()
stream.write_ulong(0)
# write the signature
stream.write(HEADER_SIGNATURE)
# write the root name
if not isinstance(name, unicode):
name = unicode(name)
stream.write_ushort(len(name))
stream.write_utf8_string(name)
# write the padding
stream.write(PADDING_BYTE * 3)
stream.write_uchar(encoding)
for n, v in values.iteritems():
encoder.writeString(n, writeType=False)
encoder.writeElement(v)
# write the padding
stream.write(PADDING_BYTE)
if strict:
stream.seek(length_pos)
stream.write_ulong(stream.remaining() - 4)
stream.seek(0)
return stream
def test_save_amf0(self):
self.jessica.put()
k = str(self.jessica.key())
encoder = pyamf.get_encoder(pyamf.AMF0)
encoder.writeElement(self.jessica)
self.assertEquals(encoder.stream.getvalue(),
'\x03\x00\x04_key\x02%s%s\x00\tbirthdate\x0bB^\xc4\xae\xaa\x00'
'\x00\x00\x00\x00\x00\x04name\x02\x00\x07Jessica\x00\x12'
'spayed_or_neutered\x01\x00\x00\x04type\x02\x00\x03cat\x00\x10'
'weight_in_pounds\x00@\x14\x00\x00\x00\x00\x00\x00\x00\x00\t' % (
struct.pack('>H', len(k)), k))
