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"})
