def test_create_response(self):
messages = [
Message({"test": "block"}, generate_id=True),
Message({
"query": {},
"param": {},
"sign": ["controller"]
},
generate_id=True)
]
def check_message(topic, qos, payload):
self.assertNotIn("query", payload)
self.assertNotIn("param", payload)
self.assertIn("sign", payload)
self.assertIn("code", payload)
self.assertIn("this is sign", payload["sign"])
self.publish._wait_published = Mock(return_value=None)
self.conn.publish = check_message
for message in messages:
resp = self.publish.create_response(message, "this is sign")
resp(500, {"ccc": "moxa best"})
self.publish._wait_published.assert_called_once_with(
ANY, no_response=True)
self.publish._wait_published.reset_mock()
def test_start(self):
del_msg = Message({
"id": 2266,
"code": 200,
"method": "post",
"resource": "/controller/registration",
"sign": ["controller"]
})
msg = Message({
"id": 1234,
"code": 200,
"method": "post",
"resource": "/controller/registration",
"sign": ["controller"],
"data": {
"tunnel": "good_luck_sanji"
}
})
thread = Thread(target=self.test_model.start)
thread.daemon = True
thread.start()
thread.join(0.1)
for msg_id in self.test_model._session.session_list:
del_msg.id = msg_id
self.test_model.res_queue.put(del_msg)
thread.join(0.1)
for msg_id in self.test_model._session.session_list:
msg.id = msg_id
self.test_model.res_queue.put(msg)
thread.join(1)
self.assertFalse(thread.is_alive())
def create(self, message, mid=None, age=60, force=True):
"""
create session
force if you pass `force = False`, it may raise SessionError
due to duplicate message id
"""
with self.session_lock:
if self.session_list.get(message.id, None) is not None:
if force is False:
raise SessionError("Message id: %s duplicate!" %
message.id)
else:
message = Message(message.to_dict(), generate_id=True)
session = {
"status": Status.CREATED,
"message": message,
"age": age,
"mid": mid,
"created_at": time(),
"is_published": Event(),
"is_resolved": Event()
}
self.session_list.update({
message.id: session
})
return session
def test_create_response(self):
messages = [
Message({"test": "block"}, generate_id=True),
Message({
"query": {},
"param": {},
"sign": ["controller"]
},
generate_id=True)
]
def send_block(msg):
response = self.publish.create_response(msg, "this is sign")
response(500, {"ccc": "moxa best"})
threads = []
for message in messages:
thread = Thread(target=send_block, args=(message, ))
thread.daemon = True
thread.start()
threads.append(thread)
map(lambda t: t.join(0.1), threads)
self.assertEqual(len(self.session.session_list), len(messages))
for session in self.session.session_list.itervalues():
session["status"] = Status.SENT
session["is_published"].set()
for thread in threads:
thread.join(0.5)
self.assertFalse(thread.is_alive())
def test__resolve_responses(self):
""" It should put message into req_queue if response is not for me """
msg = Message({
"id": 3456,
"code": 200,
"method": "get",
"resource": "/not_found/12345",
"sign": ["test"],
"data": None
})
self.test_model.res_queue.put(msg)
# start dispatch messages
thread = Thread(target=self.test_model._resolve_responses)
thread.daemon = True
thread.start()
while self.test_model.res_queue.empty() is False:
pass
event_msg_ans = Message({
"code": 200,
"method": "get",
"resource": "/not_found/12345",
"data": None
}, generate_id=False)
event_msg = self.test_model.req_queue.get()
self.assertEqual(event_msg_ans.to_dict(), event_msg.to_dict())
self.assertEqual(event_msg.type(), MessageType.EVENT)
self.test_model.res_queue.put(None)
thread.join()
def create(self, message, mid=None, age=60, force=True):
"""
create session
force if you pass `force = False`, it may raise SessionError
due to duplicate message id
"""
with self.session_lock:
if self.session_list.get(message.id, None) is not None:
if force is False:
raise SessionError("Message id: %s duplicate!" %
message.id)
else:
message = Message(message.to_dict(), generate_id=True)
session = {
"status": Status.CREATED,
"message": message,
"age": age,
"mid": mid,
"created_at": time(),
"is_published": Event(),
"is_resolved": Event()
}
self.session_list.update({message.id: session})
return session
def test__resolve_responses(self):
""" It should put message into req_queue if response is not for me """
msg = Message({
"id": 3456,
"code": 200,
"method": "get",
"resource": "/not_found/12345",
"sign": ["test"],
"data": None
})
self.test_model.res_queue.put(msg)
# start dispatch messages
thread = Thread(target=self.test_model._resolve_responses)
thread.daemon = True
thread.start()
while self.test_model.res_queue.empty() is False:
pass
event_msg_ans = Message(
{
"code": 200,
"method": "get",
"resource": "/not_found/12345",
"data": None
},
generate_id=False)
event_msg = self.test_model.req_queue.get()
self.assertEqual(event_msg_ans.to_dict(), event_msg.to_dict())
self.assertEqual(event_msg.type(), MessageType.EVENT)
self.test_model.res_queue.put(None)
thread.join()
def test__put__invalid_json(self, mock_ifaddresses, mock_ifconfig,
mock_ifupdown):
"""
put (/network/ethernets): invalid json schema
"data": [
{
"id": 1,
...
},
{
"id": 2,
...
}
]
"""
# case: invalid json schema
def resp(code=200, data=None):
self.assertEqual(400, code)
message = Message({"data": {}, "query": {}, "param": {}})
self.bundle.put(message, response=resp, test=True)
message = Message({"data": [], "query": {}, "param": {}})
self.bundle.put(message, response=resp, test=True)
message.data.append({"id": 0, "enable": True})
self.bundle.put(message, response=resp, test=True)
def test_retry(self):
# case 1: timeout
def target():
raise TimeoutError
Retry(target=target, options={"retry": False, "interval": 0})
# case 2: normal
msg = Message({})
def target2():
setattr(msg, "code", 200)
return msg
res = Retry(target=target2, options={"retry": False, "interval": 0})
self.assertEqual(res, msg)
# case 3: retry
msg = Message({})
def target2():
setattr(msg, "code", 500)
return msg
res = Retry(target=target2, options={"retry": 3, "interval": 0})
self.assertEqual(res, None)
def on_message(self, client, userdata, msg):
"""This function will recevie all message from mqtt
client
the client instance for this callback
userdata
the private user data as set in Client() or userdata_set()
message
an instance of MQTTMessage. This is a class with members topic,
payload, qos, retain.
"""
try:
message = Message(msg.payload)
except (TypeError, ValueError) as e:
logger.debug(e)
return
if message.type() == MessageType.UNKNOWN:
logger.debug("Got an UNKNOWN message, don't dispatch")
return
if message.type() == MessageType.RESPONSE:
self.res_queue.put(message)
if message.type() == MessageType.REQUEST or \
message.type() == MessageType.DIRECT or \
message.type() == MessageType.HOOK or \
message.type() == MessageType.EVENT:
self.req_queue.put(message)
def test_dispatch(self):
request = {
"id": 3345678,
"resource": "/test/resource/112?aaa=bbb",
"method": "get",
"data": {}
}
request_data = {
"uri": "test/resource/112?aaa=bbb",
"method": "get",
"param": {
"id": "112"
},
"query": {
"aaa": "bbb"
},
"data": {}
}
def callback(method):
def _cb():
return method
return _cb
# for times in range(1, 3):
self.router.post("/test/resource/", callback("post_no_id"))
self.router.route("/test/resource/:id") \
.get(callback("get")) \
.post(callback("post")) \
.delete(callback("delete")) \
.put(callback("put"))
for method in ["get", "post", "delete", "put"]:
request["method"] = method
request_data["method"] = method
result = self.router.dispatch(Message(request))
self.assertEqual(method, result[0]["callbacks"][0]())
request = {
"id": 3345678,
"resource": "/test/resource/",
"method": "post",
"data": {}
}
result = self.router.dispatch(Message(request))
self.assertEqual("post_no_id", result[0]["callbacks"][0]())
request = {
"id": 698978,
"resource": "/test/resource/",
"method": "get",
"data": {}
}
result = self.router.dispatch(Message(request))
self.assertEqual(0, len(result))
def test_to_json_with_decimal_type(self):
msg = Message({"decimalType": Decimal('0.000001')})
for prop in json.loads(msg.to_json()):
self.assertNotEqual(prop.find("_"), 0)
for prop in json.loads(msg.to_json(pretty=False)):
self.assertNotEqual(prop.find("_"), 0)
self.assertEquals(msg.to_json(pretty=False),
"{\"decimalType\": 0.000001}")
def test_event_msg(self):
msg = {
"code": 200,
"resource": "/network/cellular/1",
"method": "get",
"data": {}
}
sanjimsg = Message(msg)
self.assertEqual(sanjimsg.type(), MessageType.EVENT)
def test_request_msg(self):
msg = {
"id": 123124,
"resource": "/network/cellular/1",
"method": "get",
"data": {}
}
sanjimsg = Message(msg)
self.assertEqual(sanjimsg.type(), MessageType.REQUEST)
def test_event_msg(self):
msg = {
"code": 200,
"resource": "/network/cellular/1",
"method": "get",
"data": {}
}
sanjimsg = Message(msg)
self.assertEqual(sanjimsg.type(), MessageType.EVENT)
def test_request_msg(self):
msg = {
"id": 123124,
"resource": "/network/cellular/1",
"method": "get",
"data": {}
}
sanjimsg = Message(msg)
self.assertEqual(sanjimsg.type(), MessageType.REQUEST)
def test_hook_msg(self):
msg = {
"id": 123124,
"resource": "/network/cellular/1",
"method": "get",
"sign": ["abc", "def"],
"data": {}
}
sanjimsg = Message(msg)
self.assertEqual(sanjimsg.type(), MessageType.HOOK)
def test_to_json_with_decimal_type(self):
msg = Message({
"decimalType": Decimal('0.000001')
})
for prop in json.loads(msg.to_json()):
self.assertNotEqual(prop.find("_"), 0)
for prop in json.loads(msg.to_json(pretty=False)):
self.assertNotEqual(prop.find("_"), 0)
self.assertEquals(
msg.to_json(pretty=False), "{\"decimalType\": 0.000001}")
def test_hook_msg(self):
msg = {
"id": 123124,
"resource": "/network/cellular/1",
"method": "get",
"sign": ["abc", "def"],
"data": {}
}
sanjimsg = Message(msg)
self.assertEqual(sanjimsg.type(), MessageType.HOOK)
def test_direct_msg(self):
msg = {
"id": 123124,
"resource": "/network/cellular/1",
"method": "get",
"tunnel": "asdf",
"data": {}
}
sanjimsg = Message(msg)
self.assertEqual(sanjimsg.type(), MessageType.DIRECT)
def test_direct_msg(self):
msg = {
"id": 123124,
"resource": "/network/cellular/1",
"method": "get",
"tunnel": "asdf",
"data": {}
}
sanjimsg = Message(msg)
self.assertEqual(sanjimsg.type(), MessageType.DIRECT)
def test_response_msg(self):
msg = {
"id": 123124,
"code": 200,
"resource": "/network/cellular/1",
"method": "get",
"sign": ["test"],
"data": {}
}
sanjimsg = Message(msg)
self.assertEqual(sanjimsg.type(), MessageType.RESPONSE)
def test_response_msg(self):
msg = {
"id": 123124,
"code": 200,
"resource": "/network/cellular/1",
"method": "get",
"sign": ["test"],
"data": {}
}
sanjimsg = Message(msg)
self.assertEqual(sanjimsg.type(), MessageType.RESPONSE)
def test_match(self):
def get(self):
pass
msg = {"id": 123, "method": "get", "resource": "/model/123?abc=123"}
matched_msg = {
"_type": 2,
"resource": "/model/123?abc=123",
"query": {
"abc": "123"
},
"id": 123,
"param": {
"id": "123"
},
"method": "get"
}
sanjimsg = Message(msg)
route = Route("/model/:id")
route.get(get)
self.assertEqual(sanjimsg.match(route).__dict__, matched_msg)
msg = {"id": 123, "method": "get", "resource": "/model/123"}
matched_msg = {
"_type": 2,
"resource": "/model/123",
"query": {},
"id": 123,
"param": {
"id": "123"
},
"method": "get"
}
sanjimsg = Message(msg)
route = Route("/model/:id")
route.get(get)
self.assertEqual(sanjimsg.match(route).__dict__, matched_msg)
msg = {"id": 123, "method": "get", "resource": "/model"}
matched_msg = {
"_type": 2,
"resource": "/model",
"query": {},
"id": 123,
"param": {},
"method": "get"
}
sanjimsg = Message(msg)
route = Route("/model")
route.get(get)
self.assertEqual(sanjimsg.match(route).__dict__, matched_msg)
def test__get_by_id__unknown_iface(self, mock_ifaddresses):
"""
get_by_id (/network/ethernets/3): unknown interface
"""
mock_ifaddresses.side_effect = mock_ip_ifaddresses
message = Message({"data": {}, "query": {}, "param": {}})
# case: get an interface successfully
def resp(code=200, data=None):
self.assertEqual(404, code)
self.assertEqual(data, {"message": "No such device."})
message.param["id"] = 3
self.bundle.get_by_id(message=message, response=resp, test=True)
def test_on_message(self):
# Normal message
class MyMessage(object):
def __init__(self, payload):
self.topic = ""
self.qos = 2
self.payload = payload
# Request
message = MyMessage({
"id": 1234,
"method": "get",
"resource": "/test__dispatch_message",
"sign": ["test"],
"data": {
"test": "OK"
}
})
smessage = Message(message.payload)
self.test_model.on_message(None, None, message)
data = self.test_model.req_queue.get()
self.assertEqual(data.to_dict(), smessage.to_dict())
# Response
message2 = MyMessage({
"id": 1234,
"code": 200,
"method": "get",
"resource": "/test__dispatch_message",
"sign": ["test"],
"data": {
"test": "OK"
}
})
smessage = Message(message2.payload)
self.test_model.on_message(None, None, message2)
data = self.test_model.res_queue.get()
self.assertEqual(data.to_dict(), smessage.to_dict())
# Non-JSON String message
message = MyMessage(None)
self.test_model.on_message(None, None, message)
with self.assertRaises(Empty):
self.test_model.req_queue.get(timeout=0.1)
# UNKNOW TYPE message
message = MyMessage("{}")
self.test_model.on_message(None, None, message)
with self.assertRaises(Empty):
self.test_model.req_queue.get(timeout=0.1)
def test__event_dhcp_info__unknown_iface(self):
"""
event_dhcp_info (/network/interfaces/:iface): unknown interface
"data": {
"name": "",
"ip": "",
"netmask": "",
"subnet": "",
"dns": [],
"gateway": ""
}
"""
message = Message({
"data": {},
"query": {},
"param": {
"iface": "eth2"
}
})
message.data["name"] = "eth2"
message.data["type"] = "eth"
message.data["ip"] = "192.168.41.3"
message.data["netmask"] = "255.255.255.0"
message.data["gateway"] = "192.168.41.254"
message.data["dns"] = ["8.8.8.8"]
with self.assertRaises(ValueError):
self.bundle.event_dhcp_info(message, test=True)
def test__get_by_id__unknown_iface(self, mock_ifaddresses):
"""
get_by_id (/network/ethernets/3): unknown interface
"""
mock_ifaddresses.side_effect = mock_ip_ifaddresses
message = Message({"data": {}, "query": {}, "param": {}})
# case: get an interface successfully
def resp(code=200, data=None):
self.assertEqual(404, code)
self.assertEqual(data, {"message": "No such device."})
message.param["id"] = 3
self.bundle.get_by_id(message=message, response=resp, test=True)
def test__event_dhcp_info(self, mock_ifaddresses):
"""
event_dhcp_info (/network/interfaces/:iface)
"data": {
"name": "",
"ip": "",
"netmask": "",
"subnet": "",
"dns": [],
"gateway": ""
}
"""
message = Message({
"data": {},
"query": {},
"param": {
"iface": "eth1"
}
})
message.data["name"] = "eth1"
message.data["type"] = "eth"
message.data["ip"] = "192.168.41.3"
message.data["netmask"] = "255.255.255.0"
message.data["gateway"] = "192.168.41.254"
message.data["dns"] = ["8.8.8.8"]
self.bundle.event_dhcp_info(message, test=True)
data = self.bundle.read(2, config=True)
self.assertEqual("192.168.41.3", data["ip"])
self.assertEqual("255.255.255.0", data["netmask"])
self.assertEqual("192.168.41.254", data["gateway"])
self.assertEqual(["8.8.8.8"], data["dns"])
def test__get__by_id(self, mock_ifaddresses):
"""
get (/network/ethernets?id=2)
"""
mock_ifaddresses.side_effect = mock_ip_ifaddresses
message = Message({"data": {}, "query": {}, "param": {}})
# case: by id
def resp(code=200, data=None):
self.assertEqual(200, code)
self.assertEqual(2, data["id"])
self.assertEqual(0, data["currentStatus"])
self.assertEqual("78:ac:c0:c1:a8:ff", data["mac"])
message.query["id"] = 2
self.bundle.get(message=message, response=resp, test=True)
def test__get_by_id(self, mock_ifaddresses):
"""
get_by_id (/network/ethernets/1)
"""
mock_ifaddresses.side_effect = mock_ip_ifaddresses
message = Message({"data": {}, "query": {}, "param": {}})
# case: get an interface successfully
def resp(code=200, data=None):
self.assertEqual(200, code)
self.assertEqual(1, data["id"])
self.assertEqual(1, data["currentStatus"])
self.assertEqual("78:ac:c0:c1:a8:fe", data["mac"])
message.param["id"] = 1
self.bundle.get_by_id(message=message, response=resp, test=True)
def test_pincode_with_valid_data(code=200, data=None):
self.assertEqual(200, code)
self.assertDictContainsSubset(
data, {
"id": 0,
"apn": "hinet",
"username": "******",
"enable": 1,
"name": "root",
"ip": "",
"gateway": "",
"dns": "",
"dialNumber": "*88#",
"password": "******",
"pinCode": "",
"authType": "",
"modemPort": "/dev/cdc-wdm1",
"atPort": "/dev/ttyUSB2",
"enableAuth": 0,
"status": 0,
"delay": 40
})
test_msg["data"] = {"id": "0", "pinCode": "0000"}
message = Message(test_msg)
self.cellular.put_root_by_id(message,
response=test_pincode_with_valid_data,
test=True)
def test__get__by_id(self, mock_ifaddresses):
"""
get (/network/ethernets?id=2)
"""
mock_ifaddresses.side_effect = mock_ip_ifaddresses
message = Message({"data": {}, "query": {}, "param": {}})
# case: by id
def resp(code=200, data=None):
self.assertEqual(200, code)
self.assertEqual(2, data[0]["id"])
self.assertEqual(False, data[0]["status"])
self.assertEqual("78:ac:c0:c1:a8:ff", data[0]["mac"])
message.query["id"] = "2"
self.bundle.get(message=message, response=resp, test=True)
def test__get_by_id(self, mock_ifaddresses):
"""
get_by_id (/network/ethernets/1)
"""
mock_ifaddresses.side_effect = mock_ip_ifaddresses
message = Message({"data": {}, "query": {}, "param": {}})
# case: get an interface successfully
def resp(code=200, data=None):
self.assertEqual(200, code)
self.assertEqual(1, data["id"])
self.assertEqual(True, data["status"])
self.assertEqual("78:ac:c0:c1:a8:fe", data["mac"])
message.param["id"] = 1
self.bundle.get_by_id(message=message, response=resp, test=True)
def test_aging(self, sleep):
self.session.stop()
message1 = Message({}, generate_id=True)
# timeout (response)
self.session.create(message1, age=0)
m = self.session.stop_event = Mock()
conf = {"is_set.side_effect": [False, True, False, True]}
m.configure_mock(**conf)
self.session.aging()
try:
self.session.timeout_queue.pop()
except Exception:
self.fail("timeout_queue is empty")
# timeout (send)
self.session.create(message1, age=0)
self.session.aging()
for session in self.session.session_list.itervalues():
session["is_published"].set()
try:
self.session.timeout_queue.pop()
except Exception:
self.fail("timeout_queue is empty")
def test_resolve(self):
message1 = Message({}, generate_id=True)
self.session.create(message1)
self.assertEqual(self.session.resolve(message1.id)["message"],
message1)
# resolve unknow message
self.session.resolve(1234)
def test_create(self):
message1 = Message({}, generate_id=True)
message2 = Message({}, generate_id=True)
message3 = Message({}, generate_id=True)
# create session as normal
self.session.create(message1)
self.assertEqual(self.session.session_list[message1.id]["message"],
message1)
# id duplicate
message2.id = message1.id
session = self.session.create(message2)
self.assertNotEqual(session, None)
message3.id = message1.id
with self.assertRaises(SessionError):
self.session.create(message3, force=False)
def test_match(self):
def get(self):
pass
msg = {
"id": 123,
"method": "get",
"resource": "/model/123?abc=123"
}
matched_msg = {
"_type": 2,
"resource": "/model/123?abc=123",
"query": {"abc": "123"},
"id": 123,
"param":
{"id": "123"},
"method": "get"
}
sanjimsg = Message(msg)
route = Route("/model/:id")
route.get(get)
self.assertEqual(sanjimsg.match(route).__dict__, matched_msg)
msg = {
"id": 123,
"method": "get",
"resource": "/model/123"
}
matched_msg = {
"_type": 2,
"resource": "/model/123",
"query": {},
"id": 123,
"param":
{"id": "123"},
"method": "get"
}
sanjimsg = Message(msg)
route = Route("/model/:id")
route.get(get)
self.assertEqual(sanjimsg.match(route).__dict__, matched_msg)
def test__put__by_id(self, mock_ifaddresses, mock_ifconfig, mock_ifupdown):
"""
put (/network/ethernets): by id
"data": [
{
"id": 1,
...
},
{
"id": 2,
...
}
]
"""
message = Message({"data": [], "query": {}, "param": {}})
def mock_put(resource, data):
pass
self.bundle.publish.put = mock_put
def resp(code=200, data=None):
self.assertEqual(200, code)
self.assertEqual(True, data["enable"])
self.assertEqual("192.168.31.39", data["ip"])
message = Message({"data": {}, "query": {}, "param": {}})
message.param["id"] = 1
message.data["id"] = 1
message.data["enable"] = True
message.data["enableDhcp"] = False
message.data["ip"] = u"192.168.31.39"
def mock_event_put(resource, data):
pass
self.bundle.publish.event.put = mock_event_put
self.bundle.put(message, response=resp, test=True)
def test__event_dhcp_info(self, mock_ifaddresses):
"""
event_dhcp_info (/network/interfaces/:iface)
"data": {
"name": "",
"ip": "",
"netmask": "",
"subnet": "",
"dns": [],
"gateway": ""
}
"""
message = Message(
{"data": {}, "query": {}, "param": {"iface": "eth1"}})
message.data["name"] = "eth1"
message.data["type"] = "eth"
message.data["ip"] = "192.168.41.3"
message.data["netmask"] = "255.255.255.0"
message.data["gateway"] = "192.168.41.254"
message.data["dns"] = ["8.8.8.8"]
self.bundle.event_dhcp_info(message, test=True)
data = self.bundle.read(2, config=True)
self.assertEqual("192.168.41.3", data["ip"])
self.assertEqual("255.255.255.0", data["netmask"])
self.assertEqual("192.168.41.254", data["gateway"])
self.assertEqual(["8.8.8.8"], data["dns"])
def test_resolve_send(self):
# normal
message1 = Message({}, generate_id=True)
self.session.create(message1, mid=1)
session = self.session.resolve_send(1)
self.assertEqual(session["message"], message1)
self.assertEqual(session["status"], Status.SENT)
# not found
self.assertEqual(self.session.resolve_send(1234), None)
def _create_message(self, headers=None, data=None, generate_id=True):
payload = headers
if isinstance(data, Message):
return data
else:
if data is not None:
payload["data"] = data
return Message(payload, generate_id=generate_id)
def get_test_cases(self):
test_msg = {"id": 1, "method": "get", "resource": "/network/cellulars"}
# case 1: data
def test_get_root(code=200, data=None):
self.assertEqual(200, code)
message = Message(test_msg)
self.cellular.get_root(message, response=test_get_root, test=True)
def put_simple_test_cases(self, subprocess):
subprocess.check_output.return_value = True
subprocess.call.return_value = True
test_msg = {
"id": 12345,
"method": "put",
"param": {
"id": "1"
},
"resource": "/network/cellulars"
}
# case 1: no data attribute
def test_put_with_no_data(code=200, data=None):
self.assertEqual(400, code)
self.assertEqual(data, {"message": "Invalid Input."})
message = Message(test_msg)
self.cellular.put_root_by_id(message,
response=test_put_with_no_data,
test=True)
# case 2: data dict is empty or no enable exist
def test_put_with_random_data(code=200, data=None):
self.assertEqual(400, code)
self.assertEqual(data, {"message": "No such resources."})
test_msg["data"] = dict()
message = Message(test_msg)
self.cellular.put_root_by_id(message,
response=test_put_with_random_data,
test=True)
# case 3: data not found
def test_put_with_unknown_data(code=200, data=None):
self.assertEqual(400, code)
self.assertEqual(data, {"message": "No such resources."})
test_msg["data"] = {"path": "abcde"}
message = Message(test_msg)
self.cellular.id = 1
self.cellular.put_root_by_id(message,
response=test_put_with_unknown_data,
test=True)
def test__wait_published(self):
# SEND_TIMEOUT
session = self.session.create(Message({}, generate_id=True))
session["status"] = Status.SEND_TIMEOUT
session["is_published"].set()
with self.assertRaises(TimeoutError):
self.publish._wait_published(session)
# SENT
session = self.session.create(Message({}, generate_id=True))
session["status"] = Status.SENT
session["is_published"].set()
self.assertDictEqual(self.publish._wait_published(session), session)
# UNKNOWN
session = self.session.create(Message({}, generate_id=True))
session["status"] = 999
session["is_published"].set()
with self.assertRaises(StatusError):
self.publish._wait_published(session)
def test_dispatch(self):
request = dict(resource="/test/resource/123",
method="get",
data=dict())
def callback(req):
print(req)
self.route.get(callback)
message = Message(request)
self.assertEqual(len(self.route.dispatch(message)), 1)
def test_dispatch_multi_params(self):
request = {
"id": 3345678,
"resource": "/multi_params/1_1/2-2",
"method": "post",
"data": {}
}
callback = Mock(return_value="test_dispatch_multi_params")
self.router.route("/multi_params/:id/:u_id").post(callback)
result = self.router.dispatch(Message(request))
self.assertEqual(1, len(result))
def test__wait_resolved(self):
# RESPONSE_TIMEOUT
session = self.session.create(Message({}, generate_id=True))
session["is_resolved"].set()
session["status"] = Status.RESPONSE_TIMEOUT
with self.assertRaises(TimeoutError):
self.publish._wait_resolved(session)
# RESOLVED
session = self.session.create(Message({}, generate_id=True))
session["is_resolved"].set()
session["status"] = Status.RESOLVED
session["resolve_message"] = True
self.assertTrue(self.publish._wait_resolved(session))
# UNKNOWN
session = self.session.create(Message({}, generate_id=True))
session["is_resolved"].set()
session["status"] = 999
with self.assertRaises(StatusError):
self.publish._wait_resolved(session)
def test_init(self):
msg = Message({
"method": "get",
"resource": "/model/123"
}, generate_id=True)
self.assertGreater(msg.id, 0)
self.assertLess(msg.id, 65535)
self.assertEqual(msg.type(), MessageType.REQUEST)
msg_noid = Message({
"method": "get",
"resource": "/model/123"
})
self.assertEqual(msg_noid.type(), MessageType.UNKNOWN)
with self.assertRaises(ValueError):
Message("{")
with self.assertRaises(TypeError):
Message(123)
def test__put_by_id__unknown_iface(self, mock_ifaddresses, mock_ifconfig,
mock_ifupdown):
"""
put_by_id (/network/ethernets/3): unknown interface
"data": {
"id": 1,
...
}
"""
message = Message({"data": {}, "query": {}, "param": {}})
def mock_put(resource, data):
pass
self.bundle.publish.put = mock_put
def resp(code=200, data=None):
self.assertEqual(404, code)
message.data["id"] = 3
message.data["enable"] = 0
message.data["ip"] = u"192.168.31.37"
self.bundle.put_by_id(message, response=resp, test=True)
def test__put_by_id(self, mock_ifaddresses, mock_ifconfig, mock_ifupdown):
"""
put_by_id (/network/ethernets/1)
"data": {
"id": 1,
...
}
"""
message = Message({"data": {}, "query": {}, "param": {"id": 1}})
def mock_put(resource, data):
pass
self.bundle.publish.put = mock_put
def resp(code=200, data=None):
self.assertEqual(404, code)
message.data["id"] = 1
message.data["enable"] = False
message.data["enableDhcp"] = False
message.data["ip"] = u"192.168.31.40"
self.bundle.put_by_id(message, response=resp, test=True)
data = self.bundle.read(1, config=True)
self.assertEqual("192.168.31.40", data["ip"])
def test_unknow_msg(self):
msg = {
"id": 123124,
"resource": "/network/cellular/1",
"method": "get",
"sign": ["abc", "def"],
"tunnel": "123",
"data": {}
}
sanjimsg = Message(msg)
self.assertEqual(sanjimsg.type(), MessageType.UNKNOWN)
msg = {
"resource": "/network/cellular/1",
"method": "get",
"sign": ["abc", "def"],
"tunnel": "123",
"data": {}
}
sanjimsg = Message(msg)
self.assertEqual(sanjimsg.type(), MessageType.UNKNOWN)
msg = {
"method": "get",
"sign": ["abc", "def"],
"tunnel": "123",
}
sanjimsg = Message(msg)
self.assertEqual(sanjimsg.type(), MessageType.UNKNOWN)
msg = {
"method": "get",
"sign": ["abc", "def"],
}
sanjimsg = Message(msg)
self.assertEqual(sanjimsg.type(), MessageType.UNKNOWN)
def test__event_dhcp_info__unknown_iface(self):
"""
event_dhcp_info (/network/interfaces/:iface): unknown interface
"data": {
"name": "",
"ip": "",
"netmask": "",
"subnet": "",
"dns": [],
"gateway": ""
}
"""
message = Message(
{"data": {}, "query": {}, "param": {"iface": "eth2"}})
message.data["name"] = "eth2"
message.data["type"] = "eth"
message.data["ip"] = "192.168.41.3"
message.data["netmask"] = "255.255.255.0"
message.data["gateway"] = "192.168.41.254"
message.data["dns"] = ["8.8.8.8"]
with self.assertRaises(ValueError):
self.bundle.event_dhcp_info(message, test=True)
def test_generate_id(self):
msg = Message({})
msg_id = msg.generate_id()
self.assertEqual(msg.id, msg_id)
self.assertGreater(msg.id, 0)
self.assertLess(msg.id, 655350)
def test_generate_id(self):
msg = Message({})
msg_id = msg.generate_id()
self.assertEqual(msg.id, msg_id)
self.assertTrue(msg.id < 65535)
self.assertTrue(msg.id > 0)
def test_to_dict(self):
msg = Message({})
for prop in msg.to_dict():
self.assertNotEqual(prop.find("_"), 0)
def test__dispatch_message(self): # noqa
resp = Mock()
self.test_model.publish.create_response = Mock(return_value=resp)
# case 1: not found
with patch.object(self.test_model.router, "dispatch") as dispatch:
dispatch.return_value = []
m = Message({"resource": "/"})
self.test_model._Sanji__dispatch_message(m)
resp.assert_called_once_with(
code=404, data={"message": ANY})
# case 2: normal
def cb(self, message, response):
response(code=200, data=message.to_dict())
resp.reset_mock()
with patch.object(self.test_model.router, "dispatch") as dispatch:
dispatch.return_value = [{
"handlers": [{
"callback": cb,
"method": "put",
"reentrant": False,
"schema": None
}],
"message": Message({})
}]
self.test_model._Sanji__dispatch_message(None)
resp.assert_called_once_with(code=200, data={})
# case 3: internal error
resp.reset_mock()
dispatch.return_value = [{
"handlers": [{
"callback": Mock(side_effect=Exception("TEST"))
}],
"message": Message({})
}]
self.test_model._Sanji__dispatch_message(None)
resp.assert_called_once_with(
code=500,
data={"message": "Internal Error.", "traceback": ANY})
# case 4: schema
resp.reset_mock()
schema = Schema({
Required('q'): All(str, Length(min=1)),
Required('per_page', default=5): All(
int, Range(min=1, max=20)),
'page': All(int, Range(min=0)),
})
def schema_cb(self, message, response):
response(code=200, data=message.to_dict())
m = Message({
"data": {
"q": "abc",
"per_page": 5,
"page": 12
}
})
dispatch.return_value = [{
"handlers": [{
"callback": schema_cb,
"schema": schema
}],
"message": m
}]
self.test_model._Sanji__dispatch_message(None)
resp.assert_called_once_with(code=200,
data=m.to_dict())
# case 5: schema error
resp.reset_mock()
m = Message({
"data": {
"q": "abc",
"per_page": 5,
"page": "12" # change this to str
}
})
dispatch.return_value = [{
"handlers": [{
"callback": schema_cb,
"schema": schema
}],
"message": m
}]
self.test_model._Sanji__dispatch_message(None)
resp.assert_called_once_with(
code=400,
data={"message":
"expected int for dictionary value @ data['page']"})
# case 6: schema with extra
resp.reset_mock()
schema_extra = Schema({
Required('q'): All(str, Length(min=1))
}, extra=REMOVE_EXTRA)
m = Message({
"data": {
"q": "abc",
"extram_data": "remove_me" # extra data
}
})
dispatch.return_value = [{
"handlers": [{
"callback": schema_cb,
"schema": schema_extra
}],
"message": m
}]
self.test_model._Sanji__dispatch_message(None)
resp.assert_called_once_with(
code=200,
data={
"data": {
"q": "abc"
}
}
)
def test_to_json(self):
msg = Message({})
for prop in json.loads(msg.to_json()):
self.assertNotEqual(prop.find("_"), 0)
for prop in json.loads(msg.to_json(pretty=False)):
self.assertNotEqual(prop.find("_"), 0)
