def testPartialUnpackBlockByBlock(self):
unitSize = len(Message(MessagePackTest.map).pack())
limit = unitSize * 3
random = Random()
multi = 10
blockSizesA = [0] * (multi - 1)
for i in range(len(blockSizesA)):
blockSizesA[i] = random.randint(0, limit)
sumA = sum(blockSizesA)
lastSize = unitSize - (sumA % unitSize)
blockSizes = blockSizesA + [lastSize]
totalSize = sumA + lastSize
self.assertEqual(totalSize % unitSize, 0)
bytes = b''
for i in range(totalSize // unitSize):
bytes += Message(MessagePackTest.map).pack()
self.assertEqual(len(bytes), totalSize)
unpacker = msgpack.Unpacker(encoding='utf-8')
generated = 0
sumD = 0
for size in blockSizes:
unpacker.feed(bytes[sumD:sumD + size])
sumD += size
newGenerated = sumD // unitSize
while newGenerated > generated:
self.assertEqual(unpacker.__next__(), MessagePackTest.map)
generated += 1
self.assertRaises(StopIteration, unpacker.__next__)
self.assertEqual(generated, totalSize // unitSize)
def testTypeAndContent(self):
builder = Message.newBuilder()
self.assertEqual(builder.create().messageType(), Message.Type.Unknown)
m1 = builder.asRequest("TestRequest1").create()
self.assertEqual(m1.messageType(), Message.Type.Request)
self.assertEqual(m1.requestContent(), ("TestRequest1", [], {}))
self.assertRaises(
ProtocolException,
lambda: builder.asRequest("TestRequest2", [100, "arg"], {
"a": 1,
Message.KeyTo: "11"
}).create())
m2 = builder.asRequest("TestRequest2", [100, "arg"], {
"a": 1,
"b": "bb"
}).create()
self.assertEqual(m2.messageType(), Message.Type.Request)
self.assertEqual(m2.requestContent(), ("TestRequest2", [100, "arg"], {
"b": "bb",
"a": 1
}))
m3 = builder.asResponse("ContentOfResponse", 100).create()
self.assertEqual(m3.messageType(), Message.Type.Response)
self.assertRaises(ProtocolException, m3.requestContent)
self.assertEqual(m3.responseContent(), ("ContentOfResponse", 100))
m4 = builder.asError("ContentOfError", 1001).create()
self.assertEqual(m4.messageType(), Message.Type.Error)
self.assertRaises(ProtocolException, m4.requestContent)
self.assertRaises(ProtocolException, m4.responseContent)
self.assertEqual(m4.errorContent(), ("ContentOfError", 1001))
def testMapPackAndUnpack(self):
bytes = Message(MessagePackTest.map).pack()
unpacker = msgpack.Unpacker(encoding='utf-8')
unpacker.feed(bytes)
m1 = unpacker.__next__()
self.assertRaises(StopIteration, unpacker.__next__)
self.assertEqual(m1, MessagePackTest.map)
def testException(self):
unpacker = msgpack.Unpacker(encoding='utf-8')
bytes = Message(MessagePackTest.map).pack()
unpacker.feed(bytes)
unpacker.feed(bytes[1:-1])
unpacker.feed(bytes)
self.assertEqual(unpacker.__next__(), MessagePackTest.map)
self.assertNotEqual(unpacker.__next__(), MessagePackTest.map)
def testPartialUnpackByteByByte(self):
multi = 10
bytes = Message(MessagePackTest.map).pack()
unpacker = msgpack.Unpacker(encoding='utf-8')
for j in range(multi):
for i in range(len(bytes) - 1):
unpacker.feed(bytes[i:i + 1])
self.assertRaises(StopIteration, unpacker.__next__)
unpacker.feed(bytes[-1:])
self.assertEqual(unpacker.__next__(), MessagePackTest.map)
def testMultiUnpack(self):
multi = 100
bytes = b''
for i in range(multi):
bytes += Message(MessagePackTest.map).pack()
unpacker = msgpack.Unpacker(encoding='utf-8')
unpacker.feed(bytes)
for i in range(multi):
self.assertEqual(unpacker.__next__(), MessagePackTest.map)
self.assertRaises(StopIteration, unpacker.__next__)
def testUpdateMessage(self):
m1 = Message.newBuilder().asRequest("TestRequest1").create()
self.assertEqual(m1.get("testitem"), None)
m2 = m1 + {"testitem": 100}
self.assertEqual(m2.get("testitem"), 100)
m3 = m2.builder().create()
self.assertEqual(m3.get("testitem"), 100)
m4 = m3.builder().update({"t2": "11"}).create()
self.assertEqual(m4.get("testitem"), 100)
self.assertEqual(m4.get("t2"), "11")
r1 = m4.response(99)
self.assertEqual(r1.messageType(), Message.Type.Response)
self.assertEqual(r1.responseContent(), (99, m4.messageID()))
e1 = m4.error(999)
self.assertEqual(e1.messageType(), Message.Type.Error)
self.assertEqual(e1.errorContent(), (999, m4.messageID()))
def testMessageIDAndItsIncrecement(self):
m0 = Message.newBuilder().create()
id0 = m0.messageID()
for i in range(0, 100):
mi = Message.newBuilder().create()
self.assertTrue(mi.messageID() == id0 + 1 + i)
for m in [
Message({}),
Message({Message.KeyMessageID: "-1"}),
Message({Message.KeyMessageID: None}),
Message({Message.KeyMessageID: 1.2})
]:
self.assertRaises(ProtocolException, m.messageID)
self.assertTrue(
Message({
Message.KeyMessageID: 100
}).messageID() == 100)
def testBasicInformation(self):
b = Message.newBuilder()
self.assertIsNone(b.create().getTo())
b.to("the target")
self.assertEqual(b.create().getTo(), "the target")
def testGetInformation(self):
m = Message(MessageTest.map)
self.assertEqual(m.get("keyString"), "value1")
self.assertRaises(TypeError, lambda: m.get("keyString") + 1)
self.assertRaises(ProtocolException, lambda: m.get("keyNull", False))
self.assertIsNone(m.get("keyNull", True))
def testOverDeepth(self):
map = {"a": "b"}
for i in range(200):
map = {'a': map}
Message(map).pack()
def testFeedOverflow(self):
unpacker = msgpack.Unpacker(encoding='utf-8')
bytes = Message(MessagePackTest.map).pack()
for i in range(1000000):
unpacker.feed(bytes)