def __init__(self, json): # type (dict) -> None if "key" not in json: raise MyException("key: invalid parameter in CreateRequestParams") self.__key = json["key"] if not isinstance(self.__key, str) or len(self.__key) == 0: raise MyException("key: invalid parameter in CreateRequestParams") if "domain" not in json: raise MyException( "domain: invalid parameter in CreateRequestParams") self.__domain = json["domain"] if not isinstance(self.__domain, str) or len(self.__domain) == 0: raise MyException( "domain: invalid parameter in CreateRequestParams") if "peer_id" not in json: raise MyException( "peer_id: invalid parameter in CreateRequestParams") self.__peer_id = json["peer_id"] if not isinstance(self.__peer_id, str) or len(self.__peer_id) == 0: raise MyException( "peer_id: invalid parameter in CreateRequestParams") if "turn" not in json: raise MyException( "turn : invalid parameter in CreateRequestParams") self.__turn = json["turn"] if not isinstance(self.__turn, bool): raise MyException("turn: invalid parameter in CreateRequestParams")
def __init__(self, peer_id, token): # type: (unicode, unicode) -> None if isinstance(peer_id, str): peer_id = peer_id.decode("utf-8") if not isinstance(peer_id, unicode) or len(peer_id) == 0: raise MyException("peer_id: invalid parameter in PeerInfo") self.__peer_id = peer_id if isinstance(token, str): token = token.decode("utf-8") # TOKEN is prefix(pt-, 3words) + UUID(36words) = 39words if (not isinstance(token, unicode) or len(token) != 39 or not token.startswith("pt-")): raise MyException("token: invalid parameter in PeerInfo") self.__token = token
def __init__(self, json): # type: (dict) -> None self.__event = json["event"] if self.__event == "OPEN": self.__peer_info = PeerInfo(json["params"]["peer_id"], json["params"]["token"]) elif self.__event == "CLOSE": self.__peer_info = PeerInfo(json["params"]["peer_id"], json["params"]["token"]) elif self.__event == "CALL": self.__peer_info = PeerInfo(json["params"]["peer_id"], json["params"]["token"]) self.__media_connection_id = MediaConnectionId( json["call_params"]["media_connection_id"]) elif self.__event == "CONNECTION": self.__peer_info = PeerInfo(json["params"]["peer_id"], json["params"]["token"]) self.__data_connection_id = DataConnectionId( json["data_params"]["data_connection_id"]) elif self.__event == "ERROR": self.__peer_info = PeerInfo(json["params"]["peer_id"], json["params"]["token"]) self.__error_message = json["error_message"] else: raise MyException("This json is not an peer event")
def __init__(self, peer_id, disconnected): """ Status of a PeerObject :param unicode peer_id: id of the PeerObject :param bool disconnected: shows the peer object is disconnected or not """ if isinstance(peer_id, str): peer_id = peer_id.decode("utf-8") if not isinstance(peer_id, unicode) or len(peer_id) == 0: raise MyException("peer_id: invalid parameter in PeerStatus") self.__peer_id = peer_id if not isinstance(disconnected, bool): raise MyException("disconnected: invalid parameter in PeerStatus") self.__disconnected = disconnected
def test_delete_disconnect(self): with pytest.raises(MyException) as err: _result = self.rest.delete("disconnect", 200) assert err.value == MyException( { "url": "{}/{}".format(self.url, "disconnect"), "error": "Server Disconnected", } )
def test_get_invalid_code(self): with pytest.raises(MyException) as err: _result = self.rest.get("success", 201) assert err.value == MyException( { "url": "{}/{}".format(self.url, "success"), "error": "Unexpected Status Code", "status": 200, } )
def test_delete_400(self): with pytest.raises(MyException) as err: _result = self.rest.delete("400", 201) assert err.value == MyException( { "url": "{}/{}".format(self.url, "400"), "error": "400 Bad Request", "status": 400, } )
def test_delete_403(self): with pytest.raises(MyException) as err: _result = self.rest.delete("403", 201) assert err.value == MyException( { "url": "{}/{}".format(self.url, "403"), "error": "403 Forbidden", "status": 403, } )
def test_delete_404(self): with pytest.raises(MyException) as err: _result = self.rest.delete("404", 201) assert err.value == MyException( { "url": "{}/{}".format(self.url, "404"), "error": "404 Not Found", "status": 404, } )
def test_delete_405(self): with pytest.raises(MyException) as err: _result = self.rest.delete("405", 201) assert err.value == MyException( { "url": "{}/{}".format(self.url, "405"), "error": "405 Method Not Allowed", "status": 405, } )
def test_delete_406(self): with pytest.raises(MyException) as err: _result = self.rest.delete("406", 201) assert err.value == MyException( { "url": "{}/{}".format(self.url, "406"), "error": "406 Not Acceptable", "status": 406, } )
def test_delete_408(self): with pytest.raises(MyException) as err: _result = self.rest.delete("408", 200) assert err.value == MyException( { "url": "{}/{}".format(self.url, "408"), "error": "408 Request Timeout", "status": 408, } )
def __init__(self, data_id): """ a Value object of data_id :param unicode data_id: ID to identify the socket that will receive the data from the end user program """ if isinstance(data_id, str): data_id = data_id.decode("utf-8") # TOKEN is prefix(da-, 3words) + UUID(36words) = 39words if (not isinstance(data_id, unicode) or len(data_id) != 39 or not data_id.startswith("da-")): raise MyException("invalid data_id") self.__data_id = data_id
def __init__(self, media_id): """ a Value object of media_id :param unicode media_id: ID to identify the socket that will receive the media from the end user program """ if isinstance(media_id, str): media_id = media_id.decode("utf-8") # TOKEN is prefix(da-, 3words) + UUID(36words) = 39words if (not isinstance(media_id, unicode) or len(media_id) != 39 or (not media_id.startswith("vi-") and not media_id.startswith("au-"))): raise MyException("invalid media_id") self.__media_id = media_id
def __init__(self, media_connection_id): """ a Value object of rtcp_id :param unicode media_connection_id: ID to identify the MediaConnection """ if isinstance(media_connection_id, str): media_connection_id = media_connection_id.decode("utf-8") # TOKEN is prefix(da-, 3words) + UUID(36words) = 39words if (not isinstance(media_connection_id, unicode) or len(media_connection_id) != 39 or not media_connection_id.startswith("mc-")): raise MyException("invalid media_connection_id") self.__media_connection_id = media_connection_id
def create_request(self, param): """ Send a PeerObject create request http://35.200.46.204/#/1.peers/peer :param CreateRequestParams params: Parameters for creating a PeerObject :return: Information to identify the object :rtype: PeerInfo """ try: response = self.__rest.post("peers", param.json(), 201) except json.JSONDecodeError as e: raise MyException(e.msg) return PeerInfo(response["params"]["peer_id"], response["params"]["token"])
class TestMyError: def setup_method(self, method): self.exception = MyException({"data": "value"}) def teardown_method(self, method): del self.exception def test_check_value(self): assert self.exception.message() == {"data": "value"} def test_eq(self): assert self.exception == MyException({"data": "value"}) def test_ne(self): assert self.exception != MyException({"data": "value2"})
def __init__(self, data_connection_id): """ a Value object of data_connection_id :param unicode data_connection_id: ID to identify the DataConnection """ if isinstance(data_connection_id, str): data_connection_id = data_connection_id.decode("utf-8") # TOKEN is prefix(dc-, 3words) + UUID(36words) = 39word s if (not isinstance(data_connection_id, unicode) or len(data_connection_id) != 39 or not data_connection_id.startswith("dc-")): raise MyException("invalid media_connection_id") self.__data_connection_id = data_connection_id
def __parse_response(resp, expected_code): # type: (requests.Response, int) -> dict if resp.status_code == expected_code and expected_code == 204: return {} elif resp.status_code == expected_code: return resp.json() elif resp.status_code == 400: raise MyException({ "url": resp.url, "error": "400 Bad Request", "status": 400 }) elif resp.status_code == 403: raise MyException({ "url": resp.url, "error": "403 Forbidden", "status": 403 }) elif resp.status_code == 404: raise MyException({ "url": resp.url, "error": "404 Not Found", "status": 404 }) elif resp.status_code == 405: raise MyException({ "url": resp.url, "error": "405 Method Not Allowed", "status": 405 }) elif resp.status_code == 406: raise MyException({ "url": resp.url, "error": "406 Not Acceptable", "status": 406 }) elif resp.status_code == 408: raise MyException({ "url": resp.url, "error": "408 Request Timeout", "status": 408 }) else: raise MyException({ "url": resp.url, "error": "Unexpected Status Code", "status": resp.status_code, })
def delete_request(self, peer_info): """ Send a Delete Request of PeerObject Accessing DELETE /peers API Internally http://35.200.46.204/#/1.peers/peer_destroy :param PeerInfo peer_info: Indicates which peer object to be deleted :return: Delete succeed or not :rtype: bool """ try: self.__rest.delete( "peers/{}?token={}".format(peer_info.id(), peer_info.token()), 204 ) except json.JSONDecodeError as e: raise MyException(e.msg) return True
def get(self, path, expected_code, connect_timeout=1.0, read_timeout=30.0): # type: (str, int, float, float) -> dict headers = {"Content-Type": "application/json"} # SkyWay WebRTC Gateway's longpoll methods return timeout every 30secs. url = "{}/{}".format(self.__domain, path) try: resp = requests.get( url, headers=headers, timeout=(connect_timeout, read_timeout), ) except requests.ConnectionError: raise MyException({ "url": url, "error": "Server Disconnected", }) return Rest.__parse_response(resp, expected_code)
def listen_event(self, peer_info): """ Get an event of PeerObject http://35.200.46.204/#/1.peers/peer_event :param PeerInfo peer_info: Indicates which peer object to subscribe events :return: An event from PeerObject :rtype: PeerEvent """ try: response = self.__rest.get( "peers/{}/events?token={}".format(peer_info.id(), peer_info.token()), 200, ) except json.JSONDecodeError as e: raise MyException(e.msg) return PeerEvent(response)
def delete(self, path, expected_code, connect_timeout=1.0, read_timeout=1.0): # type: (str, int, float, float) -> dict headers = {"Content-Type": "application/json"} url = "{}/{}".format(self.__domain, path) try: resp = requests.delete( "{}/{}".format(self.__domain, path), headers=headers, timeout=(connect_timeout, read_timeout), ) except requests.ConnectionError: raise MyException({ "url": url, "error": "Server Disconnected", }) return Rest.__parse_response(resp, expected_code)
def test_eq(self): assert self.exception == MyException({"data": "value"})
def test_ne(self): assert self.exception != MyException({"data": "value2"})
def __init__(self, peer_api): # type: (IPeerApi) -> None if not isinstance(peer_api, IPeerApi): raise MyException("CreateRequest needs IPeerApi") self.__api = peer_api
def setup_method(self, method): self.exception = MyException({"data": "value"})