def broadcast_message(cls, data):
if isinstance(data, Message):
payload = Message.serialize(data).encode()
else:
payload = repr(json.dumps(data)).encode()
for c in set(cls.clients):
c = cls.clients[c]["object"]
reactor.callFromThread(c.sendMessage, payload)
def send_message(cls, peer, data):
if isinstance(data, Message):
data = Message.serialize(data).encode()
payload = repr(json.dumps(data)).encode()
LOG.info(peer)
if peer in cls.clients:
c = cls.clients[peer]["object"]
reactor.callFromThread(c.sendMessage, payload)
return True
return False
def handle_broadcast(self, message):
# send message to all clients
msg = message.data.get("payload")
is_file = message.data.get("isBinary")
if is_file:
# TODO send file
pass
else:
# send message to all clients
server_msg = Message.serialize(msg)
self.broadcast(server_msg)
def handle_send(self, message):
# send message to client
msg = message.data.get("payload")
is_file = message.data.get("isBinary")
peer = message.data.get("peer")
if is_file:
# TODO send file
pass
elif peer in self.clients:
# send message to client
client = self.clients[peer]
payload = Message.serialize(msg)
client.sendMessage(payload, False)
else:
logger.error("That client is not connected")
self.emitter_send("client.send.error", {
"error": "That client is not connected",
"peer": peer
}, message.context)
def test_runner(self, dir):
if self.verbose > 0:
print "Testing skill: " + dir
test_suite = self.read_test_suite(dir)
for test_case in test_suite:
op = self.test_case_to_op(test_case)
_m = Message("recognizer_loop:utterance", {
"lang": "en-us",
"utterances": [test_case['utterance']]
})
self.ws.send(_m.serialize())
if self.verbose > 0:
print "Test case: " + str(test_case)
print "Utterance: " + str(test_case['utterance'])
timeout = time.time() + 30
while True:
try:
result = json.loads(self.ws.recv())
if self.verbose > 1:
print result
for _x in op:
self.op_evaluate(_x, result)
if not filter(lambda x: x[-1] != 'succeeded', op):
break
if time.time() > timeout:
break
except WebSocketTimeoutException:
pass
if not filter(lambda x: x[-1] != 'succeeded', op):
print OKGREEN + "Succeeded: " + test_case['intent_type'] + ENDC
else:
print FAIL + "Failed: " + test_case['intent_type'] + ENDC
self.succeeded = False
break
if self.verbose > 0:
print "Test status: " + str(op)
class TestMessageMethods(unittest.TestCase):
"""This tests the Message class functions
"""
def setUp(self):
"""This sets up some basic messages for testing.
"""
self.empty_message = Message("empty")
self.message1 = Message("enclosure.reset")
self.message2 = Message("enclosure.system.blink", {'target': 4},
{'target': 5})
self.message3 = Message("status", "OK")
# serialized results of each of the messages
self.serialized = [
'{"data": {}, "type": "empty", "context": null}',
'{"data": {}, "type": "enclosure.reset",\
"context": null}', '{"data": { "target": 4}, \
"type": "enclosure.system.blink", \
"context": {"target": 5}}',
'{"data": "OK", "type": "status", \
"context": null}'
]
def test_serialize(self):
"""This test the serialize method
"""
self.assertEqual(self.empty_message.serialize(), self.serialized[0])
self.assertEqual(self.message1.serialize(), self.serialized[1])
self.assertEqual(self.message2.serialize(), self.serialized[2])
self.assertEqual(self.message3.serialize(), self.serialized[3])
def test_deserialize(self):
"""This test's the deserialize method
"""
messages = []
# create the messages from the serialized strings above
messages.append(Message.deserialize(self.serialized[0]))
messages.append(Message.deserialize(self.serialized[1]))
messages.append(Message.deserialize(self.serialized[2]))
# check the created messages match the strings
self.assertEqual(messages[0].serialize(), self.serialized[0])
self.assertEqual(messages[1].serialize(), self.serialized[1])
self.assertEqual(messages[2].serialize(), self.serialized[2])
def test_reply(self):
"""This tests the reply method
This is probably incomplete as the use of the reply message escapes me.
"""
message = self.empty_message.reply("status", "OK")
self.assertEqual(message.serialize(),
'{"data": "OK", "type": "status", "context": {}}')
message = self.message1.reply("status", "OK")
self.assertEqual(message.serialize(),
'{"data": "OK", "type": "status", "context": {}}')
message = self.message2.reply("status", "OK")
def test_publish(self):
"""This is for testing the publish method
TODO: Needs to be completed
"""
pass
class TestMessageMethods(unittest.TestCase):
"""This tests the Message class functions
"""
def setUp(self):
"""This sets up some basic messages for testing.
"""
self.empty_message = Message("empty")
self.message1 = Message("enclosure.reset")
self.message2 = Message("enclosure.system.blink",
{'target': 4}, {'target': 5})
self.message3 = Message("status", "OK")
# serialized results of each of the messages
self.serialized = ['{"data": {}, "type": "empty", "context": null}',
'{"data": {}, "type": "enclosure.reset",\
"context": null}',
'{"data": { "target": 4}, \
"type": "enclosure.system.blink", \
"context": {"target": 5}}',
'{"data": "OK", "type": "status", \
"context": null}']
def test_serialize(self):
"""This test the serialize method
"""
self.assertEqual(self.empty_message.serialize(), self.serialized[0])
self.assertEqual(self.message1.serialize(), self.serialized[1])
self.assertEqual(self.message2.serialize(), self.serialized[2])
self.assertEqual(self.message3.serialize(), self.serialized[3])
def test_deserialize(self):
"""This test's the deserialize method
"""
messages = []
# create the messages from the serialized strings above
messages.append(Message.deserialize(self.serialized[0]))
messages.append(Message.deserialize(self.serialized[1]))
messages.append(Message.deserialize(self.serialized[2]))
# check the created messages match the strings
self.assertEqual(messages[0].serialize(), self.serialized[0])
self.assertEqual(messages[1].serialize(), self.serialized[1])
self.assertEqual(messages[2].serialize(), self.serialized[2])
def test_reply(self):
"""This tests the reply method
This is probably incomplete as the use of the reply message escapes me.
"""
message = self.empty_message.reply("status", "OK")
self.assertEqual(message.serialize(),
'{"data": "OK", "type": "status", "context": {}}')
message = self.message1.reply("status", "OK")
self.assertEqual(message.serialize(),
'{"data": "OK", "type": "status", "context": {}}')
message = self.message2.reply("status", "OK")
def test_publish(self):
"""This is for testing the publish method
TODO: Needs to be completed
"""
pass