def test_deep(self):
class A(object):
pass
alias = pyamf.register_class(A, 'A')
alias.static_attrs = ['a']
class B(A):
pass
alias = pyamf.register_class(B, 'B')
alias.static_attrs = ['b']
class C(B):
pass
alias = pyamf.register_class(C, 'C')
alias.static_attrs = ['c']
x = C()
x.a = 'spam'
x.b = 'eggs'
x.c = 'foo'
self.assertEncoded(x,
'\n;\x03C\x03b\x03a\x03c\x06\teggs\x06\tspam\x06\x07foo\x01')
def test_person(self):
pyamf.register_class(models.Person, 'Person')
person_key = ndb.Key('Contact', 'p')
person = models.Person(
key=person_key,
first_name='Foo',
last_name='Bar',
)
bytes = (
b'\n\x0b\rPerson', (
b'\t_key\x06Qagx0ZXN0YmVkLXRlc3RyDgsSB0NvbnRhY3QiAXAM',
b'\x19phone_number\x01',
b'\x0faddress\x01',
b'\x15first_name\x06\x07Foo',
b'\x13last_name\x06\x07Bar',
),
b'\x01'
)
self.assertEncodes(person, bytes)
def check_person(ret):
self.assertIsInstance(ret, models.Person)
self.assertEqual(ret, person)
self.assertDecodes(bytes, check_person)
def test_company(self):
pyamf.register_class(models.Company, 'Company')
company_key = ndb.Key('Contact', 'c')
company = models.Company(
key=company_key,
name='Acme Ltd',
)
bytes = (
b'\n\x0b\x0fCompany', (
b'\t_key\x06Qagx0ZXN0YmVkLXRlc3RyDgsSB0NvbnRhY3QiAWMM',
b'\x19phone_number\x01',
b'\x0faddress\x01',
b'\tname\x06\x11Acme Ltd',
),
b'\x01'
)
self.assertEncodes(company, bytes)
def check_company(ret):
self.assertIsInstance(ret, models.Company)
self.assertEqual(ret, company)
self.assertDecodes(bytes, check_company)
def test_decode_amf3(self):
pyamf.register_class(models.ListModel, "list-model")
bytes = "\n\x0b\x15list-model\x0fnumbers\t\x0b\x01\x04\x02\x04\x04\x04" "\x06\x04\x08\x04\n\x01"
x = self.decode(bytes, encoding=pyamf.AMF3)
self._check_list(x)
def test_expando(self):
pyamf.register_class(models.SuperHero, 'SH')
superman = models.SuperHero(name='Clark Kent', can_fly=True)
superman.has_cape = True
bytes = (
b'\n\x0b\x05SH', (
b'\x0fcan_fly\x03',
b'\rslogan\x01',
b'\tname\x06\x15Clark Kent',
b'\x11has_cape\x03',
b'\t_key\x01',
),
b'\x01'
)
self.assertEncodes(superman, bytes)
def check_superman(ret):
self.assertIsInstance(ret, models.SuperHero)
self.assertEqual(ret, superman)
self.assertTrue(ret.has_cape)
self.assertDecodes(bytes, check_superman)
def test_typed_object(self):
pyamf.register_class(Spam, alias="org.pyamf.spam")
x = Spam()
x.baz = "hello"
self.assertEncoded(x, "\x10\x00\x0eorg.pyamf.spam\x00\x03baz" "\x02\x00\x05hello\x00\x00\t")
def tearDown(self):
import pyamf
pyamf.unregister_class(status.Status)
if self._old_alias:
pyamf.register_class(self._old_alias)
def save(self, out, format):
"""
"""
#
# Serialize
#
if format == "WKT":
if "wkt" in self.content["crs"]:
out.write(self.content["crs"]["wkt"])
else:
out.write(_sref_4326().ExportToWkt())
return
if format in ("GeoJSON", "GeoBSON", "GeoAMF"):
content = self.content
if "wkt" in content["crs"]:
content["crs"] = {"type": "link", "properties": {"href": "0.wkt", "type": "ogcwkt"}}
else:
del content["crs"]
elif format in ("ArcJSON", "ArcBSON", "ArcAMF"):
content = reserialize_to_arc(self.content, format == "ArcAMF")
else:
raise KnownUnknown(
'Vector response only saves .geojson, .arcjson, .geobson, .arcbson, .geoamf, .arcamf and .wkt tiles, not "%s"'
% format
)
#
# Encode
#
if format in ("GeoJSON", "ArcJSON"):
indent = self.verbose and 2 or None
encoded = JSONEncoder(indent=indent).iterencode(content)
float_pat = compile(r"^-?\d+\.\d+$")
for atom in encoded:
if float_pat.match(atom):
out.write("%.6f" % float(atom))
else:
out.write(atom)
elif format in ("GeoBSON", "ArcBSON"):
import bson
encoded = bson.dumps(content)
out.write(encoded)
elif format in ("GeoAMF", "ArcAMF"):
import pyamf
for class_name in pyamf_classes.items():
pyamf.register_class(*class_name)
encoded = pyamf.encode(content, 0).read()
out.write(encoded)
def test_dynamic(self):
pyamf.register_class(Spam, 'abc.xyz')
x = Spam({'spam': 'eggs'})
self.encoder.writeElement(x)
self.assertEqual(self.buf.getvalue(), '\n\x0b\x0fabc.xyz\tspam\x06\teggs\x01')
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 __BuildBrightCoveAmfRequest(self, playerKey, contentId, url, experienceId, seed, contentRefId):
""" Builds a AMF request compatible with BrightCove
Arguments:
playerKey : string - Key identifying the current request
contentId : int - ID of the content to retrieve
url : string - Url of the page that calls the video SWF
seed : string - Constant which depends on the website
Keyword Arguments:
experienceId : id - <unknown parameter>
Returns a valid Brightcove request
"""
if self.logger:
self.logger.Debug("Creating BrightCover request for ContentId=%s, Key=%s, ExperienceId=%s, url=%s", contentId, playerKey, experienceId, url)
else:
print "Creating BrightCover request for ContentId=%s, Key=%s, ExperienceId=%s, url=%s" % (contentId, playerKey, experienceId, url)
# const = '686a10e2a34ec3ea6af8f2f1c41788804e0480cb'
pyamf.register_class(ViewerExperienceRequest, 'com.brightcove.experience.ViewerExperienceRequest')
pyamf.register_class(ContentOverride, 'com.brightcove.experience.ContentOverride')
contentOverrides = [ContentOverride(int(contentId), contentRefId=contentRefId)]
viewerExperienceRequest = ViewerExperienceRequest(url, contentOverrides, int(experienceId), playerKey)
envelope = remoting.Envelope(amfVersion=self.amfVersion)
remotingRequest = remoting.Request(target="com.brightcove.experience.ExperienceRuntimeFacade.getDataForExperience", body=[seed, viewerExperienceRequest], envelope=envelope)
envelope.bodies.append(("/1", remotingRequest))
return envelope
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 BuildAmfRequest(self, key, url, exp_id, contentRefId = None, contentId = None):
self.log(u'ContentRefId:' + str(contentRefId) + u'contentId:' + str(contentId) + u', ExperienceId:' + str(exp_id) + u', URL:' + url)
method = u"com.brightcove.experience.ExperienceRuntimeFacade.getDataForExperience"
className = method[0:method.rfind('.')]
hashValue = self.GetAmfClassHash(className)
self.log(u'hashValue:' + str(hashValue))
pyamf.register_class(ViewerExperienceRequest, u'com.brightcove.experience.ViewerExperienceRequest')
pyamf.register_class(ContentOverride, u'com.brightcove.experience.ContentOverride')
content_override = ContentOverride(contentRefId = contentRefId, contentId = contentId)
viewer_exp_req = ViewerExperienceRequest(url, [content_override], int(exp_id), key)
self.log( content_override.tostring() )
self.log( viewer_exp_req.tostring() )
env = remoting.Envelope(amfVersion=3)
env.bodies.append(
(
"/1",
remoting.Request(
target=method,
body=[hashValue, viewer_exp_req],
envelope=env
)
)
)
return env
def GetEpisodeInfo(self, key, url, playerId, contentRefId = None, contentId = None):
self.log(u'ContentRefId:' + str(contentRefId) + u'contentId:' + str(contentId) + u', URL:' + url + u', playerId: ' + unicode(playerId) + u', key: ' + unicode(key) )
self.log(u"RemotingService", xbmc.LOGDEBUG)
try:
if self.proxyConfig is not None:
self.proxyConfig.Enable()
serviceName = 'com.brightcove.experience.ExperienceRuntimeFacade'
service = self.GetRemotingService(key, serviceName)
hashValue = self.GetAmfClassHash(serviceName)
self.log(u'hashValue:' + str(hashValue))
pyamf.register_class(ViewerExperienceRequest, 'com.brightcove.experience.ViewerExperienceRequest')
pyamf.register_class(ContentOverride, 'com.brightcove.experience.ContentOverride')
content_override = ContentOverride(contentRefId = contentRefId, contentId = contentId)
viewer_exp_req = ViewerExperienceRequest(url, [content_override], int(playerId), key)
self.log( content_override.tostring() )
self.log( viewer_exp_req.tostring() )
# Make the request
response = service.getDataForExperience(hashValue, viewer_exp_req)
self.log(u"response: " + utils.drepr(response), xbmc.LOGDEBUG)
finally:
if self.proxyConfig is not None:
self.proxyConfig.Disable()
return response
def test_decode(self):
pyamf.register_class(PetModel, "Pet")
k = str(self.jessica.key())
bytes = (
"\x10\x00\x03Pet\x00\x04_key\x02%s%s\x00\x04type\x02\x00"
+ "\x03cat\x00\x10weight_in_pounds\x00@\x14\x00\x00\x00\x00\x00"
+ "\x00\x00\x04name\x02\x00\x07Jessica\x00\tbirthdate\x0bB^\xc4"
+ "\xae\xaa\x00\x00\x00\x00\x00\x00\x12spayed_or_neutered"
+ "\x01\x00\x00\x00\t"
)
bytes = bytes % (struct.pack(">H", len(k)), k)
decoder = pyamf.get_decoder(pyamf.AMF0)
context = decoder.context
stream = decoder.stream
stream.write(bytes * 2)
stream.seek(0)
j = decoder.readElement()
alias = context.getClassAlias(PetModel)
self.assertTrue(isinstance(j, PetModel))
self.assertTrue(isinstance(alias, adapter_db.DataStoreClassAlias))
self.assertEquals(context.gae_objects, {PetModel: {k: j}})
j2 = decoder.readElement()
self.assertTrue(isinstance(j2, PetModel))
self.assertEquals(context.gae_objects, {PetModel: {k: j}})
def test_get_reference(self):
x = amf3.Context()
y = [1, 2, 3]
z = {'spam': 'eggs'}
spam_alias = pyamf.register_class(Spam, 'spam.eggs')
class Foo:
pass
foo_alias = pyamf.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('abc')
x.addString('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('abc'), 0)
self.assertEqual(x.getStringReference('def'), 1)
self.assertEqual(x.getStringReference('asdfas'), -1)
self.assertEqual(x.getClass(Spam), a)
self.assertEqual(x.getClass(Foo), b)
self.assertEqual(x.getClass(object()), None)
def test_decode(self):
pyamf.register_class(ListModel, "list-model")
decoder = pyamf.get_decoder(pyamf.AMF0)
decoder.stream.write(
"\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"
)
decoder.stream.seek(0)
x = decoder.readElement()
self.assertTrue(isinstance(x, ListModel))
self.assertTrue(hasattr(x, "numbers"))
self.assertEquals(x.numbers, [2, 4, 6, 8, 10])
decoder = pyamf.get_decoder(pyamf.AMF3)
decoder.stream.write("\n\x0b\x15list-model\x0fnumbers\t\x0b\x01\x04\x02\x04" "\x04\x04\x06\x04\x08\x04\n\x01")
decoder.stream.seek(0)
x = decoder.readElement()
self.assertTrue(isinstance(x, ListModel))
self.assertTrue(hasattr(x, "numbers"))
self.assertEquals(x.numbers, [2, 4, 6, 8, 10])
def test_external(self):
class A(object):
pass
class B:
pass
self.assertRaises(AttributeError, pyamf.register_class, A, metadata=["external"])
self.assertRaises(AttributeError, pyamf.register_class, B, metadata=["external"])
A.__readamf__ = None
B.__readamf__ = None
self.assertRaises(AttributeError, pyamf.register_class, A, metadata=["external"])
self.assertRaises(AttributeError, pyamf.register_class, B, metadata=["external"])
A.__readamf__ = lambda x: None
B.__readamf__ = lambda x: None
self.assertRaises(AttributeError, pyamf.register_class, A, metadata=["external"])
self.assertRaises(AttributeError, pyamf.register_class, B, metadata=["external"])
A.__writeamf__ = "foo"
B.__writeamf__ = "bar"
self.assertRaises(TypeError, pyamf.register_class, A, metadata=["external"])
self.assertRaises(TypeError, pyamf.register_class, B, metadata=["external"])
A.__writeamf__ = lambda x: None
B.__writeamf__ = lambda x: None
pyamf.register_class(A, metadata=["external"])
pyamf.register_class(B, metadata=["external"])
def test_dynamic(self):
pyamf.register_class(Spam, attr_func=ord, metadata=['dynamic'])
alias = pyamf.CLASS_CACHE['%s.%s' % (Spam.__module__, Spam.__name__,)]
self.assertTrue('dynamic' in alias.metadata)
self.assertEquals(alias.attr_func, ord)
def test_but_missing(self):
"""
.model is set to a key but the entity does not exist - pyamf must
handle the encode and decode cases.
"""
pyamf.register_class(models.Pet, 'pet')
pyamf.register_class(models.SuperModel, 'supermodel')
pet_key = ndb.Key('Pet', 'foobar')
model_key = ndb.Key('SuperModel', 'barfoo')
self.assertIsNone(model_key.get())
pet = models.Pet(key=pet_key, model=model_key)
pet.put()
bytes = (
b'\n\x0b\x07pet', (
b'\t_key\x06Uagx0ZXN0YmVkLXRlc3RyDwsSA1BldCIGZm9vYmFyDA',
b'\x0bmodel\x06gagx0ZXN0YmVkLXRlc3RyFgsSClN1cGVyTW9kZWwiBmJhcm'
b'Zvbww',
b'\tname\x01',
),
b'\x01'
)
self.assertEncodes(pet, bytes)
self.assertDecodes(bytes, pet)
def test_simple(self):
class A(object):
class __amf__:
static = ('a')
class B(A):
class __amf__:
static = ('b')
pyamf.register_class(A, 'A')
pyamf.register_class(B, 'B')
x = B()
x.a = 'spam'
x.b = 'eggs'
stream = util.BufferedByteStream()
encoder = pyamf._get_encoder_class(pyamf.AMF0)(stream)
encoder.writeElement(x)
self.assertTrue(check_buffer(stream.getvalue(), ('\x10\x00\x01B', (
'\x00\x01a\x02\x00\x04spam',
'\x00\x01b\x02\x00\x04eggs'
), '\x00\x00\t')))
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 main():
"""
Entry point for this client script.
"""
url = 'http://%s:%d' % (host_info[0], host_info[1])
client = RemotingService(url, logger=logging)
print "Client running - pointing to server at %s" % url
# at this point, calling the service gets us a dict of values
user_service = client.getService('user')
lenards = user_service.get_user('lenards')
# in case you don't believe me - this shows I'm not lying
logging.debug("isinstance(lenards, dict): %s" % isinstance(lenards, dict))
# the User class attributes are not present at this point
logging.debug("not hasattr(lenards, 'username'): %s" %
(not hasattr(lenards, 'username')))
logging.debug("not hasattr(lenards, 'email'): %s" %
(not hasattr(lenards, 'email')))
logging.debug("not hasattr(lenards, 'password'): %s" %
(not hasattr(lenards, 'password')))
# but the values are there
logging.debug("lenards['username'] == 'lenards': %s" %
(lenards['username'] == 'lenards'))
logging.debug("lenards['email'] == '*****@*****.**': %s" %
(lenards['email'] == '*****@*****.**'))
logging.debug("Output 'lenards': %s" % lenards)
# if we register the class and the namespace, we get an object ref
# (complete with attributes and such)
logging.debug("Register UserDataTransferObject class...")
pyamf.register_class(UserDataTransferObject, '%s.User' % AMF_NAMESPACE)
logging.debug("Get a user from the server...")
usr = user_service.get_user('lisa')
# ensure it's the class we expect
logging.debug("Ensure the class we got is our DTO, " +
"isinstance(usr, UserDataTransferObject): %s" %
isinstance(usr, UserDataTransferObject))
# verify it has expected attributes
logging.debug("Verify attributes present...")
logging.debug("usr.username: %s" % usr.username)
logging.debug("usr.email == '*****@*****.**': %s" %
(usr.email == '*****@*****.**'))
logging.debug("usr.password == 'h1k3r': %s" %
(usr.password == 'h1k3r'))
logging.debug("Output user returned: %s" % usr)
# request an unknown user
logging.debug("Try to get a user that does not exist...")
george = user_service.get_user('george')
logging.debug("Output returned: %s" % george)
def test_typed_object(self):
pyamf.register_class(Spam, alias='org.pyamf.spam')
x = Spam()
x.baz = 'hello'
self.assertEncoded(x, '\x10\x00\x0eorg.pyamf.spam\x00\x03baz'
'\x02\x00\x05hello\x00\x00\t')
def setUp(self):
BaseTestCase.setUp(self)
JessicaMixIn.setUp(self)
pyamf.register_class(self.jessica_class, 'Pet')
self.put(self.jessica)
self.key = str(self.jessica.key())
def test_anonymous(self):
pyamf.register_class(Spam)
x = pyamf.get_class_alias(Spam)
self.assertTrue(isinstance(x, pyamf.ClassAlias))
self.assertEquals(x.klass, Spam)
self.assertEquals(x.alias, '%s.%s' % (Spam.__module__, Spam.__name__,))
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 test_none(self):
pyamf.register_class(test_models.ListModel, 'list-model')
bytes = '\x10\x00\nlist-model\x00\x07numbers\x05\x00\x00\t'
x = self.decode(bytes, encoding=pyamf.AMF0)
self.assertEqual(x.numbers, [])
def setUp(self):
e.create_all()
self.movie_alias = pyamf.register_class(Movie, 'movie')
self.genre_alias = pyamf.register_class(Genre, 'genre')
self.director_alias = pyamf.register_class(Director, 'director')
self.create_movie_data()
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')])
def test_object(self):
pyamf.register_class(Spam, 'org.pyamf.spam')
self.buf.truncate(0)
self.buf.write(
'\x0a\x13\x1dorg.pyamf.spam\x07baz\x06\x0b\x68\x65\x6c\x6c\x6f')
self.buf.seek(0)
obj = self.decoder.readElement()
self.assertEqual(obj.__class__, Spam)
self.assertTrue(hasattr(obj, 'baz'))
self.assertEqual(obj.baz, 'hello')
def test_typed(self):
class XYZ(Exception):
pass
pyamf.register_class(XYZ, 'foo.bar')
try:
raise XYZ('blarg')
except Exception as e:
self.encoder.writeElement(e)
self.assertEqual(
self.buf.getvalue(), '\n\x0b\x0ffoo.bar\x0f'
'message\x06\x0bblarg\tname\x06\x07XYZ\x01')
def test_alias_amf0(self):
pyamf.register_class(models.PetExpando, 'Pet')
bytes = pyamf.encode(self.jessica, encoding=pyamf.AMF0).getvalue()
self.assertBuffer(
bytes,
('\x10\x00\x03Pet',
('\x00\x04_key%s' % self.encodeKey(self.jessica, pyamf.AMF0),
'\x00\tbirthdate\x0bB^\xc4\xae\xaa\x00\x00\x00\x00\x00',
'\x00\x04name\x02\x00\x07Jessica',
'\x00\x12spayed_or_neutered\x01\x00',
'\x00\x04type\x02\x00\x03cat',
'\x00\x10weight_in_pounds\x00@\x14\x00\x00\x00\x00\x00\x00',
'\x00\x03foo\x02\x00\x03bar'), '\x00\x00\t'))
def test_dynamic(self):
pyamf.register_class(Spam, 'abc.xyz')
self.buf.write('\x0a\x0b\x0fabc.xyz\x09spam\x06\x09eggs\x01')
self.buf.seek(0, 0)
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_registered_alias(self):
x = pyamf.BaseContext()
self.assertEquals(x.class_aliases, {})
class A:
pass
pyamf.register_class(A)
alias = x.getClassAlias(A)
self.assertTrue(isinstance(alias, pyamf.ClassAlias))
self.assertEquals(alias.__class__, pyamf.ClassAlias)
self.assertEquals(alias.klass, A)
def test_slots_registered(self):
class Person(object):
__slots__ = ('family_name', 'given_name')
u = Person()
u.family_name = 'Doe'
u.given_name = 'Jane'
pyamf.register_class(Person, 'spam.eggs.Person')
self.encoder.writeElement(u)
self.assertEquals(self.buf.getvalue(), '\x10\x00\x10spam.eggs.Person'
'\x00\x0bfamily_name\x02\x00\x03Doe\x00\ngiven_name\x02\x00\x04'
'Jane\x00\x00\t')
def test_get_by_reference(self):
x = amf3.Context()
y = [1, 2, 3]
z = {'spam': 'eggs'}
alias_spam = pyamf.register_class(Spam, 'spam.eggs')
class Foo:
pass
class Bar:
pass
alias_foo = pyamf.register_class(Foo, 'foo.bar')
a = amf3.ClassDefinition(alias_spam)
b = amf3.ClassDefinition(alias_foo)
x.addObject(y)
x.addObject(z)
x.addString('abc')
x.addString('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), 'abc')
self.assertEqual(x.getString(1), 'def')
self.assertEqual(x.getString(2), None)
self.assertRaises(TypeError, x.getString, '')
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_simple_named_alias(self):
"""
Register SimpleEntity as a named class.
"""
pyamf.register_class(models.SimpleEntity, 'foo.bar')
entity = models.SimpleEntity()
self.assertEncodes(
entity,
(b'\x10\x00', b'\x07foo.bar', b'\x00\x04_key\x05', b'\x00\x00\t'),
encoding=pyamf.AMF0)
self.assertEncodes(entity, ('\n\x0b\x0ffoo.bar\t_key\x01\x01'),
encoding=pyamf.AMF3)
def test_metadata(self):
self.assertRaises(ValueError,
pyamf.register_class,
Spam,
'spam.eggs',
metadata=['static'])
pyamf.register_class(Spam,
'spam.eggs',
metadata=['static'],
attrs=['x'])
alias = pyamf.CLASS_CACHE['spam.eggs']
self.assertEquals(alias.metadata, ['static'])
self.assertEquals(alias.attrs, ['x'])
self.assertTrue(isinstance(alias.metadata, pyamf.ClassMetaData))
def test_nonexternal_subclassed_list(self):
class L(list):
pass
pyamf.register_class(L, 'a')
a = L()
a.append('foo')
a.append('bar')
self.encoder.writeElement(a)
self.assertEquals(self.buf.getvalue(),
'\n\x00\x00\x00\x02\x02\x00\x03foo\x02\x00\x03bar')
def setUp(self):
a = pyamf.register_class(builder.SomeClass,
builder.aliases[builder.SomeClass])
a.compile()
builder.SomeStaticClass.__amf__ = {
'dynamic': False,
'static': ('name', 'score', 'rank')
}
a = pyamf.register_class(builder.SomeStaticClass,
builder.aliases[builder.SomeStaticClass])
a.compile()
def test_typed(self):
class XYZ(Exception):
pass
pyamf.register_class(XYZ, 'foo.bar')
try:
raise XYZ('blarg')
except Exception as e:
self.encoder.writeElement(e)
self.assertEqual(
self.buffer.getvalue(), '\x10\x00\x07foo.bar\x00'
'\x07message\x02\x00\x05blarg\x00\x04name\x02\x00\x03XYZ\x00\x00\t'
)
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.assertEncoded(u, '\x10\x00\x10spam.eggs.Person',
('\x00\x0bfamily_name\x02\x00\x03Doe',
'\x00\ngiven_name\x02\x00\x04Jane'), '\x00\x00\t')
def test_static_attrs(self):
class Foo(object):
class __amf__:
static = ('foo', 'bar')
pyamf.register_class(Foo)
x = Foo()
x.foo = 'baz'
x.bar = 'gak'
self.assertEncoded(
x, '\x03',
('\x00\x03bar\x02\x00\x03gak', '\x00\x03foo\x02\x00\x03baz'),
'\x00\x00\t')
def test_slots_registered(self):
class Person(object):
__slots__ = ('family_name', 'given_name')
pyamf.register_class(Person, 'spam.eggs.Person')
self.buf.write('\x10\x00\x10spam.eggs.Person\x00\x0bfamily_name\x02'
'\x00\x03Doe\x00\ngiven_name\x02\x00\x04Jane\x00\x00\t')
self.buf.seek(0)
foo = self.decoder.readElement()
self.assertTrue(isinstance(foo, Person))
self.assertEqual(foo.family_name, 'Doe')
self.assertEqual(foo.given_name, 'Jane')
def test_encode_amf0_registered(self):
pyamf.register_class(test_models.ListModel, 'list-model')
bytes = (
'\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@\x20\x00\x00\x00'
'\x00\x00\x00\x00@$\x00\x00\x00\x00\x00\x00'
),
'\x00\x00\t'
)
self.assertEncodes(self.obj, bytes, encoding=pyamf.AMF0)
def test_alias_amf3(self):
pyamf.register_class(test_models.PetExpando, 'Pet')
bytes = (
'\n\x0b\x07Pet', (
'\tname\x06\x0fJessica',
'\t_key%s' % self.encodeKey(self.jessica, pyamf.AMF3),
'\x13birthdate\x08\x01B^\xc4\xae\xaa\x00\x00\x00',
'!weight_in_pounds\x04\x05',
'\x07foo\x06\x07bar',
'\ttype\x06\x07cat',
'%spayed_or_neutered\x02\x01'
))
self.assertEncodes(self.jessica, bytes, encoding=pyamf.AMF3)
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_static_attrs(self):
class Foo(object):
class __amf__:
static = ('foo', 'bar')
pyamf.register_class(Foo)
x = Foo()
x.foo = 'baz'
x.bar = 'gak'
self.encoder.writeElement(x)
self.assertEquals(
self.buf.getvalue(), '\x03\x00\x03bar\x02\x00\x03gak'
'\x00\x03foo\x02\x00\x03baz\x00\x00\t')
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(), '\x10\x00\x10spam.eggs.Person'
'\x00\x0bfamily_name\x02\x00\x03Doe\x00\ngiven_name\x02\x00\x04'
'Jane\x00\x00\t')
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_alias_amf0(self):
pyamf.register_class(test_models.PetModel, 'Pet')
bytes = (
'\x10\x00\x03Pet', (
'\x00\x04_key%s' % self.encodeKey(self.jessica, pyamf.AMF0),
'\x00\tbirthdate\x0bB^\xc4\xae\xaa\x00\x00\x00\x00\x00',
'\x00\x04name\x02\x00\x07Jessica',
'\x00\x12spayed_or_neutered\x01\x00',
'\x00\x04type\x02\x00\x03cat',
'\x00\x10weight_in_pounds\x00@\x14\x00\x00\x00\x00\x00\x00'
),
'\x00\x00\t'
)
self.assertEncodes(self.jessica, bytes, encoding=pyamf.AMF0)
def test_slots(self):
class Person(object):
__slots__ = ('family_name', 'given_name')
pyamf.register_class(Person, 'spam.eggs.Person')
self.buf.write('\n+!spam.eggs.Person\x17family_name\x15given_name\x06'
'\x07Doe\x06\tJane\x02\x06\x06\x04\x06\x08\x01')
self.buf.seek(0)
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_model(self):
a = Author(name='Jane Austen')
self.put(a)
k = str(a.key())
amf0_k = struct.pack('>H', len(k)) + k
amf3_k = amf3.encode_int(len(k) << 1 | amf3.REFERENCE_BIT) + k
b = Novel(title='Sense and Sensibility', author=a)
self.assertIdentical(b.author, a)
bytes = ('\x03', ('\x00\x05title\x02\x00\x15Sense and Sensibility',
'\x00\x04_key\x02' + amf0_k, '\x00\x06author\x03',
('\x00\x04name\x02\x00\x0bJane Austen',
'\x00\x04_key\x05'), '\x00\x00\t'), '\x00\x00\t')
self.assertEncodes(b, bytes, encoding=pyamf.AMF0)
bytes = ('\n\x0b\x01',
(('\rauthor\n\x0b\x01', ('\t_key\x06' + amf3_k,
'\tname\x06\x17Jane Austen'),
'\x01\x06\x01'),
'\x0btitle\x06+Sense and Sensibility'), '\x01')
self.assertEncodes(b, bytes, encoding=pyamf.AMF3)
# now test with aliases ..
pyamf.register_class(Author, 'Author')
pyamf.register_class(Novel, 'Novel')
bytes = ('\x10\x00\x05Novel',
('\x00\x05title\x02\x00\x15Sense and Sensibility',
'\x00\x04_key\x02' + amf0_k,
'\x00\x06author\x10\x00\x06Author',
('\x00\x04name\x02\x00\x0bJane Austen',
'\x00\x04_key\x05'), '\x00\x00\t'), '\x00\x00\t')
self.assertEncodes(b, bytes, encoding=pyamf.AMF0)
bytes = ('\n\x0b\x0bNovel',
(('\rauthor\n\x0b\rAuthor', ('\t_key\x06' + amf3_k,
'\tname\x06\x17Jane Austen'),
'\x01\n\x01'),
'\x0btitle\x06+Sense and Sensibility'), '\x01')
self.assertEncodes(b, bytes, encoding=pyamf.AMF3)
def test_model(self):
a = test_models.Author(name='Jane Austen')
self.put(a)
k = str(a.key())
amf0_k = self.encodeKey(a, pyamf.AMF0)
amf3_k = self.encodeKey(a, pyamf.AMF3)
b = test_models.Novel(title='Sense and Sensibility', author=a)
self.assertIdentical(b.author, a)
bytes = ('\x03', ('\x00\x05title\x02\x00\x15Sense and Sensibility',
'\x00\x04_key' + amf0_k, '\x00\x06author\x03',
('\x00\x04name\x02\x00\x0bJane Austen',
'\x00\x04_key\x05'), '\x00\x00\t'), '\x00\x00\t')
self.assertEncodes(b, bytes, encoding=pyamf.AMF0)
bytes = ('\n\x0b\x01',
(('\rauthor\n\x0b\x01', ('\t_key' + amf3_k,
'\tname\x06\x17Jane Austen'),
'\x01\x06\x01'),
'\x0btitle\x06+Sense and Sensibility'), '\x01')
self.assertEncodes(b, bytes, encoding=pyamf.AMF3)
# now test with aliases ..
pyamf.register_class(test_models.Author, 'Author')
pyamf.register_class(test_models.Novel, 'Novel')
bytes = ('\x10\x00\x05Novel',
('\x00\x05title\x02\x00\x15Sense and Sensibility',
'\x00\x04_key' + amf0_k, '\x00\x06author\x10\x00\x06Author',
('\x00\x04name\x02\x00\x0bJane Austen',
'\x00\x04_key\x05'), '\x00\x00\t'), '\x00\x00\t')
self.assertEncodes(b, bytes, encoding=pyamf.AMF0)
bytes = ('\n\x0b\x0bNovel',
(('\rauthor\n\x0b\rAuthor', ('\t_key' + amf3_k,
'\tname\x06\x17Jane Austen'),
'\x01\n\x01'),
'\x0btitle\x06+Sense and Sensibility'), '\x01')
self.assertEncodes(b, bytes, encoding=pyamf.AMF3)
def get_clip_info(self, contentID, url):
import pyamf
#from pyamf import register_class
from pyamf import remoting
import httplib
conn = httplib.HTTPConnection("c.brightcove.com")
pyamf.register_class(ViewerExperienceRequest, 'com.brightcove.experience.ViewerExperienceRequest')
pyamf.register_class(ContentOverride, 'com.brightcove.experience.ContentOverride')
viewer_exp_req = ViewerExperienceRequest(url, [ContentOverride(contentID)], self.urls['experienceID'], "")
env = remoting.Envelope(amfVersion = 3)
env.bodies.append(("/1", remoting.Request(target = "com.brightcove.experience.ExperienceRuntimeFacade.getDataForExperience", body = [self.urls['const'], viewer_exp_req], envelope = env)))
#conn.request("POST", "/services/messagebroker/amf?playerKey=" + self.urls['playerKey'], str(remoting.encode(env).read()), {'content-type': 'application/x-amf'})
conn.request("POST", "/services/messagebroker/amf?playerId=" + self.urls['playerID'], str(remoting.encode(env).read()), {'content-type': 'application/x-amf'})
resp = conn.getresponse().read()
response = remoting.decode(resp).bodies[0][1].body
self._printResponse(env, response)
return response['programmedContent']['videoPlayer']['mediaDTO']['renditions']
def test_force_amf3(self):
alias = pyamf.register_class(Spam, 'spam.eggs')
alias.amf3 = True
x = Spam()
x.x = 'y'
self.assertEncoded(x, '\x11\n\x0b\x13spam.eggs\x03x\x06\x03y\x01')
def __BuildBrightCoveAmfRequest(self, playerKey, contentId, url,
experienceId, seed):
""" Builds a AMF request compatible with BrightCove
Arguments:
playerKey : string - Key identifying the current request
contentId : int - ID of the content to retrieve
url : string - Url of the page that calls the video SWF
seed : string - Constant which depends on the website
Keyword Arguments:
experienceId : id - <unknown parameter>
Returns a valid Brightcove request
"""
if self.logger:
self.logger.Debug(
"Creating BrightCover request for ContentId=%s, Key=%s, ExperienceId=%s, url=%s",
contentId, playerKey, experienceId, url)
else:
print "Creating BrightCover request for ContentId=%s, Key=%s, ExperienceId=%s, url=%s" % (
contentId, playerKey, experienceId, url)
# const = '686a10e2a34ec3ea6af8f2f1c41788804e0480cb'
pyamf.register_class(
ViewerExperienceRequest,
'com.brightcove.experience.ViewerExperienceRequest')
pyamf.register_class(ContentOverride,
'com.brightcove.experience.ContentOverride')
contentOverrides = [ContentOverride(str(contentId))]
viewerExperienceRequest = ViewerExperienceRequest(
url, contentOverrides, int(experienceId), playerKey)
envelope = remoting.Envelope(amfVersion=self.amfVersion)
remotingRequest = remoting.Request(
target=
"com.brightcove.experience.ExperienceRuntimeFacade.getDataForExperience",
body=[seed, viewerExperienceRequest],
envelope=envelope)
envelope.bodies.append(("/1", remotingRequest))
return envelope
def test_external_subclassed_list(self):
class L(list):
def __readamf__(self, o):
pass
def __writeamf__(self, o):
pass
pyamf.register_class(L, 'a', metadata=['external'])
a = L()
a.append('foo')
a.append('bar')
self.encoder.writeElement(a)
self.assertEquals(self.buf.getvalue(), '\x10\x00\x01a\x00\x00\t')
def test_simple(self):
class A(object):
pass
alias = pyamf.register_class(A, 'A')
alias.static_attrs = ['a']
class B(A):
pass
alias = pyamf.register_class(B, 'B')
alias.static_attrs = ['b']
x = B()
x.a = 'spam'
x.b = 'eggs'
self.assertEncoded(x, '\n+\x03B\x03a\x03b\x06\tspam\x06\teggs\x01')
