def test_create(self):
sp = util.BufferedByteStream()
self.assertEqual(sp.tell(), 0)
self.assertEqual(sp.getvalue(), '')
self.assertEqual(len(sp), 0)
self.assertEqual(sp.getvalue(), '')
sp = util.BufferedByteStream(None)
self.assertEqual(sp.tell(), 0)
self.assertEqual(sp.getvalue(), '')
self.assertEqual(len(sp), 0)
sp = util.BufferedByteStream('')
self.assertEqual(sp.tell(), 0)
self.assertEqual(sp.getvalue(), '')
self.assertEqual(len(sp), 0)
sp = util.BufferedByteStream('spam')
self.assertEqual(sp.tell(), 0)
self.assertEqual(sp.getvalue(), 'spam')
self.assertEqual(len(sp), 4)
sp = util.BufferedByteStream(StringIO('this is a test'))
self.assertEqual(sp.tell(), 0)
self.assertEqual(sp.getvalue(), 'this is a test')
self.assertEqual(len(sp), 14)
self.assertRaises(TypeError, util.BufferedByteStream, self)
def test_encode(self):
stream = util.BufferedByteStream()
encoder = amf3.Encoder(stream)
x = flex.ArrayCollection()
x['spam'] = 'eggs'
encoder.writeElement(x)
self.assertEquals(
stream.getvalue(), '\n\x07Cflex.messaging.io.ArrayCollection'
'\t\x01\tspam\x06\teggs\x01')
stream = util.BufferedByteStream()
encoder = amf0.Encoder(stream)
x = flex.ArrayCollection()
x['spam'] = 'eggs'
encoder.writeElement(x)
self.assertEquals(
stream.getvalue(),
'\x11\n\x07Cflex.messaging.io.ArrayCollection\t\x01\tspam\x06\x09'
'eggs\x01')
def test_add(self):
a = util.BufferedByteStream('a')
b = util.BufferedByteStream('b')
c = a + b
self.assertTrue(isinstance(c, util.BufferedByteStream))
self.assertEqual(c.getvalue(), 'ab')
self.assertEqual(c.tell(), 0)
def test_create(self):
x = util.BufferedByteStream()
self.assertEqual(x.getvalue(), '')
self.assertEqual(x.tell(), 0)
x = util.BufferedByteStream('abc')
self.assertEqual(x.getvalue(), 'abc')
self.assertEqual(x.tell(), 0)
def test_add_pos(self):
a = util.BufferedByteStream('abc')
b = util.BufferedByteStream('def')
a.seek(1)
b.seek(0, 2)
self.assertEqual(a.tell(), 1)
self.assertEqual(b.tell(), 3)
self.assertEqual(a.tell(), 1)
self.assertEqual(b.tell(), 3)
def test_deep(self):
class A(object):
pass
pyamf.register_class(A, 'A', attrs=['a'])
class B(A):
pass
pyamf.register_class(B, 'B', attrs=['b'])
class C(B):
pass
pyamf.register_class(C, 'C', attrs=['c'])
x = C()
x.a = 'spam'
x.b = 'eggs'
x.c = 'foo'
stream = util.BufferedByteStream()
encoder = pyamf._get_encoder_class(pyamf.AMF0)(stream)
encoder.writeElement(x)
self.assertEquals(
stream.getvalue(), '\x10\x00\x01C\x00\x01a\x02\x00'
'\x04spam\x00\x01c\x02\x00\x03foo\x00\x01b\x02\x00\x04eggs\x00'
'\x00\t')
pyamf.unregister_class(A)
pyamf.unregister_class(B)
pyamf.unregister_class(C)
def test_decode(self):
stream = util.BufferedByteStream()
decoder = pyamf._get_decoder_class(pyamf.AMF0)(stream)
stream.write(
'\x10\x00\tRecordSet\x00\n'
'serverInfo\x08\x00\x00\x00\x00\x00\x06cursor\x00?\xf0\x00\x00\x00'
'\x00\x00\x00\x00\x0bcolumnNames\n\x00\x00\x00\x03\x02\x00\x01a'
'\x02\x00\x01b\x02\x00\x01c\x00\x0binitialData\n\x00\x00\x00\x03'
'\n\x00\x00\x00\x03\x00?\xf0\x00\x00\x00\x00\x00\x00\x00@\x00\x00'
'\x00\x00\x00\x00\x00\x00@\x08\x00\x00\x00\x00\x00\x00\n\x00\x00'
'\x00\x03\x00@\x10\x00\x00\x00\x00\x00\x00\x00@\x14\x00\x00\x00'
'\x00\x00\x00\x00@\x18\x00\x00\x00\x00\x00\x00\n\x00\x00\x00\x03'
'\x00@\x1c\x00\x00\x00\x00\x00\x00\x00@ \x00\x00\x00\x00\x00\x00'
'\x00@"\x00\x00\x00\x00\x00\x00\x00\x07version\x00?\xf0\x00\x00'
'\x00\x00\x00\x00\x00\ntotalCount\x00@\x08\x00\x00\x00\x00\x00\x00'
'\x00\x00\t\x00\x00\t')
stream.seek(0, 0)
x = decoder.readElement()
self.assertTrue(isinstance(x, amf0.RecordSet))
self.assertEquals(x.columns, ['a', 'b', 'c'])
self.assertEquals(x.items, [[1, 2, 3], [4, 5, 6], [7, 8, 9]])
self.assertEquals(x.service, None)
self.assertEquals(x.id, None)
def decode(stream, context=None, strict=False):
"""
Decodes the incoming stream.
@type stream: L{BufferedByteStream<pyamf.util.BufferedByteStream>}
@param stream: AMF data.
@type context: L{amf0.Context<pyamf.amf0.Context>} or
L{amf3.Context<pyamf.amf3.Context>}
@param context: Context.
@type strict: C{bool}
@param strict: Enforce strict encoding. Default is C{False}.
@raise DecodeError: Malformed stream.
@raise RuntimeError: Decoder is unable to fully consume the
stream buffer.
@return: Message envelope.
@rtype: L{Envelope}
"""
if not isinstance(stream, util.BufferedByteStream):
stream = util.BufferedByteStream(stream)
msg = Envelope()
msg.amfVersion = stream.read_uchar()
# see http://osflash.org/documentation/amf/envelopes/remoting#preamble
# why we are doing this...
if msg.amfVersion > 0x09:
raise pyamf.DecodeError("Malformed stream (amfVersion=%d)" %
msg.amfVersion)
if context is None:
context = pyamf.get_context(pyamf.AMF0)
else:
context = copy.copy(context)
decoder = pyamf._get_decoder_class(pyamf.AMF0)(stream, context=context, strict=strict)
msg.clientType = stream.read_uchar()
header_count = stream.read_ushort()
for i in xrange(header_count):
name, required, data = _read_header(stream, decoder, strict)
msg.headers[name] = data
if required:
msg.headers.set_required(name)
body_count = stream.read_short()
for i in range(body_count):
context.reset()
target, payload = _read_body(stream, decoder, strict)
msg[target] = payload
if strict and stream.remaining() > 0:
raise RuntimeError("Unable to fully consume the buffer")
return msg
def test_deep(self):
class A(object):
class __amf__:
static = ('a')
class B(A):
class __amf__:
static = ('b')
class C(B):
class __amf__:
static = ('c')
pyamf.register_class(A, 'A')
pyamf.register_class(B, 'B')
pyamf.register_class(C, 'C')
x = C()
x.a = 'spam'
x.b = 'eggs'
x.c = 'foo'
stream = util.BufferedByteStream()
encoder = pyamf._get_encoder_class(pyamf.AMF0)(stream)
encoder.writeElement(x)
self.assertTrue(
check_buffer(
stream.getvalue(),
('\x10\x00\x01C',
('\x00\x01a\x02\x00\x04spam', '\x00\x01c\x02\x00\x03foo',
'\x00\x01b\x02\x00\x04eggs'), '\x00\x00\t')))
def encode(*args, **kwargs):
"""
A helper function to encode an element.
@type element: C{mixed}
@keyword element: Python data.
@type encoding: C{int}
@keyword encoding: AMF encoding type.
@type context: L{amf0.Context<pyamf.amf0.Context>} or
L{amf3.Context<pyamf.amf3.Context>}
@keyword context: Context.
@rtype: C{StringIO}
@return: File-like object.
"""
encoding = kwargs.get('encoding', AMF0)
context = kwargs.get('context', None)
strict = kwargs.get('strict', False)
stream = util.BufferedByteStream()
encoder = _get_encoder_class(encoding)(stream, context, strict)
for el in args:
encoder.writeElement(el)
stream.seek(0)
return stream
def __init__(self, data=None, context=None, strict=False):
"""
@type data: L{BufferedByteStream<pyamf.util.BufferedByteStream>}
@param data: Data stream.
@type context: L{Context<pyamf.amf0.Context>}
@param context: Context.
@raise TypeError: The C{context} parameter must be of type
L{Context<pyamf.amf0.Context>}.
"""
# coerce data to BufferedByteStream
if isinstance(data, util.BufferedByteStream):
self.stream = data
else:
self.stream = util.BufferedByteStream(data)
if context == None:
self.context = self.context_class()
elif isinstance(context, self.context_class):
self.context = context
else:
raise TypeError("context must be of type %s.%s" % (
self.context_class.__module__, self.context_class.__name__))
self._write_elem_func_cache = {}
self.strict = strict
def test_seek(self):
sp = util.BufferedByteStream('abcdefghijklmnopqrstuvwxyz')
self.assertEqual(sp.getvalue(), 'abcdefghijklmnopqrstuvwxyz')
self.assertEqual(sp.tell(), 0)
# Relative to the beginning of the stream
sp.seek(0, 0)
self.assertEqual(sp.tell(), 0)
self.assertEqual(sp.getvalue(), 'abcdefghijklmnopqrstuvwxyz')
self.assertEqual(sp.read(1), 'a')
self.assertEqual(len(sp), 26)
sp.seek(10, 0)
self.assertEqual(sp.tell(), 10)
self.assertEqual(sp.getvalue(), 'abcdefghijklmnopqrstuvwxyz')
self.assertEqual(sp.read(1), 'k')
self.assertEqual(len(sp), 26)
sp.seek(-5, 1)
self.assertEqual(sp.tell(), 6)
self.assertEqual(sp.getvalue(), 'abcdefghijklmnopqrstuvwxyz')
self.assertEqual(sp.read(1), 'g')
self.assertEqual(len(sp), 26)
sp.seek(-3, 2)
self.assertEqual(sp.tell(), 23)
self.assertEqual(sp.getvalue(), 'abcdefghijklmnopqrstuvwxyz')
self.assertEqual(sp.read(1), 'x')
self.assertEqual(len(sp), 26)
def test_really_bad_decode(self):
self.old_method = remoting.decode
remoting.decode = lambda *args, **kwargs: self._raiseException(
Exception, *args, **kwargs)
request = util.BufferedByteStream()
env = {
'REQUEST_METHOD': 'POST',
'CONTENT_LENGTH': str(len(request)),
'wsgi.input': request
}
def start_response(status, headers):
self.executed = True
self.assertEquals(status, '500 Internal Server Error')
self.assertTrue(('Content-Type', 'text/plain') in headers)
try:
response = self.gw(env, start_response)
except:
remoting.decode = self.old_method
raise
remoting.decode = self.old_method
self.assertEquals(response, [
'500 Internal Server Error\n\nAn unexpec'
'ted error occurred whilst decoding.'
])
self.assertTrue(self.executed)
def test_unknown_request(self):
request = util.BufferedByteStream()
request.write(
'\x00\x00\x00\x00\x00\x01\x00\x09test.test\x00'
'\x02/1\x00\x00\x00\x14\x0a\x00\x00\x00\x01\x08\x00\x00\x00\x00'
'\x00\x01\x61\x02\x00\x01\x61\x00\x00\x09')
request.seek(0, 0)
env = {
'REQUEST_METHOD': 'POST',
'CONTENT_LENGTH': str(len(request)),
'wsgi.input': request
}
def start_response(status, headers):
self.executed = True
self.assertEquals(status, '200 OK')
self.assertTrue(('Content-Type', 'application/x-amf') in headers)
response = self.gw(env, start_response)
envelope = remoting.decode(''.join(response))
message = envelope['/1']
self.assertEquals(message.status, remoting.STATUS_ERROR)
body = message.body
self.assertTrue(isinstance(body, remoting.ErrorFault))
self.assertEquals(body.code, 'Service.ResourceNotFound')
self.assertTrue(self.executed)
def test_write_double(self):
x = util.BufferedByteStream()
self._write_endian(
x, x.write_double, (0.2, ),
('?\xc9\x99\x99\x99\x99\x99\x9a', '\x9a\x99\x99\x99\x99\x99\xc9?'))
self.assertRaises(TypeError, x.write_double, 'foo')
def test_read_char(self):
x = util.BufferedByteStream('\x00\x7f\xff\x80')
self.assertEqual(x.read_char(), 0)
self.assertEqual(x.read_char(), 127)
self.assertEqual(x.read_char(), -1)
self.assertEqual(x.read_char(), -128)
def test_getvalue(self):
sp = util.BufferedByteStream()
sp.write('asdfasdf')
self.assertEqual(sp.getvalue(), 'asdfasdf')
sp.write('spam')
self.assertEqual(sp.getvalue(), 'asdfasdfspam')
def test_peek(self):
x = util.BufferedByteStream('abcdefghijklmnopqrstuvwxyz')
self.assertEquals(x.tell(), 0)
self.assertEquals(x.peek(), 'a')
self.assertEquals(x.peek(5), 'abcde')
self.assertEquals(x.peek(-1), 'abcdefghijklmnopqrstuvwxyz')
def test_bad_request(self):
gw = self._makeOne()
body = util.BufferedByteStream()
body.write('Bad request')
body.seek(0, 0)
response = self.doRequest(body, gw)
self.assertEqual(response.status_int, 400)
def _read_endian(self, data, func, args, expected):
for x in range(2):
obj = util.BufferedByteStream(data[x])
obj.endian = self.endians[x]
result = getattr(obj, func)(*args)
self.assertEqual(result, expected)
def test_decode_amf0(self):
stream = util.BufferedByteStream(
'\x11\n\x07Cflex.messaging.io.ArrayCollection\t\x03\x01\x06\teggs')
decoder = amf0.Decoder(stream)
x = decoder.readElement()
self.assertEqual(x.__class__, flex.ArrayCollection)
self.assertEqual(x, ['eggs'])
def format_exception():
import traceback
f = util.BufferedByteStream()
traceback.print_exc(file=f)
return f.getvalue()
def test_remaining(self):
x = util.BufferedByteStream('spameggs')
self.assertEqual(x.tell(), 0)
self.assertEqual(x.remaining(), 8)
x.seek(2)
self.assertEqual(x.tell(), 2)
self.assertEqual(x.remaining(), 6)
def test_read_negative(self):
"""
@see: #799
"""
x = util.BufferedByteStream()
x.write('*' * 6000)
x.seek(100)
self.assertRaises(IOError, x.read, -345)
def test_write_utf8_string(self):
x = util.BufferedByteStream()
self._write_endian(x, x.write_utf8_string, (u'ᚠᛇᚻ', ),
['\xe1\x9a\xa0\xe1\x9b\x87\xe1\x9a\xbb'] * 2)
self.assertRaises(TypeError, x.write_utf8_string, 1)
self.assertRaises(TypeError, x.write_utf8_string, 1.0)
self.assertRaises(TypeError, x.write_utf8_string, object())
x.write_utf8_string('\xff')
def check_amf3(self, bytes, xml):
b = util.BufferedByteStream(bytes)
self.assertEqual(b.read_char(), 11)
l = b.read_uchar()
self.assertEqual(l >> 1, b.remaining())
self.assertEqual(b.read(), xml)
def test_eof(self):
x = util.BufferedByteStream()
self.assertTrue(x.at_eof())
x.write('hello')
x.seek(0)
self.assertFalse(x.at_eof())
x.seek(0, 2)
self.assertTrue(x.at_eof())
def test_read(self):
x = util.BufferedByteStream()
x.read()
self.assertRaises(EOFError, x.read, 10)
x.write('hello')
x.seek(0)
self.assertRaises(IOError, x.read, 10)
def test_read(self):
sp = util.BufferedByteStream('this is a test')
self.assertEqual(len(sp), 14)
self.assertEqual(sp.read(1), 't')
self.assertEqual(sp.getvalue(), 'this is a test')
self.assertEqual(len(sp), 14)
self.assertEqual(sp.read(10), 'his is a t')
self.assertEqual(sp.read(), 'est')
def test_eof_decode(self):
gw = self._makeOne()
gw.debug = True
body = util.BufferedByteStream()
body.seek(0, 0)
response = self.doRequest(body, gw)
assert 'The request body was unable to be successfully decoded' in response.detail
assert 'Traceback' in response.detail
self.assertEqual(response.status_int, 400)