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_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_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_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__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)