def test_deserialize_invalid_type_ws_msg():
data = json.dumps({
'_type': 9999,
'location': {
'latitude': 0.0,
'longitude': 1.0
}
})
with pytest.raises(ValueError):
deserialize_ws_message(data)
async def _on_message(self, message: str) -> None:
logger.debug("Received message from user_id = '{}' : '{}'".format(
self.user_id, message))
try:
msg = models.deserialize_ws_message(message)
except (ValueError, TypeError) as e:
self.write_as_json(
ErrorMessage(WebSocketErrorType.INVALID_MESSAGE.value))
logger.error(
"Invalid message received by user_id : '{}', exception : '{}'".
format(self.user_id, e))
else:
if isinstance(msg, models.LocationUpdateMessage):
self.handle_location_update(msg)
elif isinstance(msg, models.ParkingRequestMessage):
await self.handle_parking_request(msg)
elif isinstance(msg, models.ParkingAcceptanceMessage):
await self.handle_parking_acceptance(msg)
elif isinstance(msg, models.ParkingRejectionMessage):
self.handle_parking_rejection(msg)
elif isinstance(msg, models.ParkingCancellationMessage):
self.handle_parking_cancellation(msg)
else:
logger.warning(
"Unimplemented message received from user_id = '{}'".
format(self.user_id))
self.write_as_json(
ErrorMessage(WebSocketErrorType.NOT_IMPLEMENTED.value))
async def test_parking_request_message(ws_url, user_id, mocker, engine):
user_location = Location(0.0, 1.0)
lot_location = Location(0.001, 1.0)
lot_allocation = ParkingLotAllocation(100,
"test_lot",
0,
lot_location,
1,
distance=50.0,
availability=20)
parking_request = ParkingRequestMessage(user_location)
mocker.patch.object(engine, 'handle_allocation_request')
engine.handle_allocation_request.return_value = return_async_value(
lot_allocation)
conn: WebSocketClientConnection = await tornado.websocket.websocket_connect(
ws_url + user_id)
await conn.write_message(serialize_model(parking_request))
msg = deserialize_ws_message(await conn.read_message())
engine.handle_allocation_request.assert_called_once_with(
user_id, parking_request)
assert isinstance(msg, ParkingAllocationMessage)
assert msg.lot == lot_allocation
def test_deserialize_valid_ws_msg():
data = json.dumps({
'_type': 1,
'location': {
'latitude': 0.0,
'longitude': 1.0
}
})
msg = deserialize_ws_message(data)
assert isinstance(msg, LocationUpdateMessage)
async def test_another_connection_open(ws_url):
await tornado.websocket.websocket_connect(ws_url)
conn2: WebSocketClientConnection = await tornado.websocket.websocket_connect(
ws_url)
msg = deserialize_ws_message(await conn2.read_message())
assert WebSocketErrorType(
msg.error) == WebSocketErrorType.ANOTHER_CONNECTION_OPEN
# confirm that second connection was closed
assert await conn2.read_message() is None
async def test_internal_error(ws_url, user_id, mocker, usessions):
conn: WebSocketClientConnection = await tornado.websocket.websocket_connect(
ws_url + user_id)
session: UserWSHandler = usessions.get_user(user_id).session
mocker.patch.object(session, '_on_message', side_effect=NameError())
await conn.write_message("test")
msg = deserialize_ws_message(await conn.read_message())
assert WebSocketErrorType(msg.error) == WebSocketErrorType.INTERNAL
def _on_message(self, message: str):
message = ws_models.deserialize_ws_message(message)
message_type = message.__class__
if message_type in self._receive_callbacks:
self._receive_callbacks[message_type](message)
elif message_type in self._waiting:
future_set_result_unless_cancelled(self._waiting[message_type],
message)
del self._waiting[message_type]
else:
self._message_queue[message_type].append(message)
async def test_parking_rejection_message(ws_url, user_id, mocker, usessions):
lot_id = 7
mocker.spy(usessions, "add_user_rejection")
conn: WebSocketClientConnection = await tornado.websocket.websocket_connect(
ws_url + user_id)
await conn.write_message(serialize_model(ParkingRejectionMessage(lot_id)))
msg = deserialize_ws_message(await conn.read_message())
usessions.add_user_rejection.assert_called_once_with(user_id, lot_id)
assert isinstance(msg, ConfirmationMessage)
async def test_db_error(ws_url, user_id, mocker, usessions):
conn: WebSocketClientConnection = await tornado.websocket.websocket_connect(
ws_url + user_id)
session: UserWSHandler = usessions.get_user(user_id).session
from asyncpg import PostgresError
mocker.patch.object(session,
'_on_message',
side_effect=PostgresError.new({}))
await conn.write_message("test")
msg = deserialize_ws_message(await conn.read_message())
assert WebSocketErrorType(msg.error) == WebSocketErrorType.DATABASE
async def test_parking_acceptance_message_happy_case(ws_url, user_id, mocker,
dbaccess, engine):
lot_id = 7
mocker.patch.object(dbaccess, "allocate_parking_lot")
dbaccess.allocate_parking_lot.return_value = return_async_value(True)
mocker.spy(engine, "commit_allocation")
conn: WebSocketClientConnection = await tornado.websocket.websocket_connect(
ws_url + user_id)
await conn.write_message(serialize_model(ParkingAcceptanceMessage(lot_id)))
msg = deserialize_ws_message(await conn.read_message())
engine.commit_allocation.assert_called_once_with(user_id, lot_id)
assert isinstance(msg, ConfirmationMessage)
async def test_parking_acceptance_message_failed_commit(
ws_url, user_id, mocker, dbaccess, engine):
lot_id = 7
mocker.patch.object(dbaccess, "allocate_parking_lot")
dbaccess.allocate_parking_lot.return_value = return_async_value(False)
mocker.spy(engine, "commit_allocation")
conn: WebSocketClientConnection = await tornado.websocket.websocket_connect(
ws_url + user_id)
await conn.write_message(serialize_model(ParkingAcceptanceMessage(lot_id)))
msg = deserialize_ws_message(await conn.read_message())
engine.commit_allocation.assert_called_once_with(user_id, lot_id)
assert WebSocketErrorType(
msg.error) == WebSocketErrorType.ALLOCATION_COMMIT_FAIL
async def test_parking_request_message_no_parking_lot(ws_url, user_id, mocker,
engine):
user_location = Location(0.0, 1.0)
parking_request = ParkingRequestMessage(user_location)
mocker.patch.object(engine, 'handle_allocation_request')
engine.handle_allocation_request.return_value = return_async_value(None)
conn: WebSocketClientConnection = await tornado.websocket.websocket_connect(
ws_url + user_id)
await conn.write_message(serialize_model(parking_request))
msg = deserialize_ws_message(await conn.read_message())
engine.handle_allocation_request.assert_called_once_with(
user_id, parking_request)
assert WebSocketErrorType(
msg.error) == WebSocketErrorType.NO_AVAILABLE_PARKING_LOT
def on_message(self, message: str) -> None:
logger.debug("Received message from user_id = '{}' : '{}'".format(self.user_id, message))
msg = models.deserialize_ws_message(message)
if isinstance(msg, models.LocationUpdateMessage):
logger.debug("Received location update from user_id = '{}'".format(self.user_id))
self.usessions.update_user_location(self.user_id, msg.location)
elif isinstance(msg, models.ParkingRequestMessage):
logger.debug("Received parking request from user_id = '{}'".format(self.user_id))
elif isinstance(msg, models.ParkingAcceptanceMessage):
logger.debug("Received parking acceptance from user_id = '{}'".format(self.user_id))
elif isinstance(msg, models.ParkingRejectionMessage):
logger.debug("Received parking rejection from user_id = '{}'".format(self.user_id))
self.usessions.add_user_rejection(self.user_id, msg.id)
elif isinstance(msg, models.ParkingCancellationMessage):
logger.info("Parking cancelled for user_id = '{}'".format(self.user_id))
self.close()
async def test_invalid_message(ws_url, user_id):
conn: WebSocketClientConnection = await tornado.websocket.websocket_connect(
ws_url + user_id)
await conn.write_message("test")
msg = deserialize_ws_message(await conn.read_message())
assert WebSocketErrorType(msg.error) == WebSocketErrorType.INVALID_MESSAGE