def test_user_already_exists(self):
models.UserConfig(uuid=123456,
login="******",
password="******")
run_method = controller.ProtocolMethods(self.test)
result = json.loads(run_method.get_response())
self.assertEqual(result["errors"]["code"], 409)
def test_check_wrong_auth_id(self):
auth_id = "wrong_auth_id"
uuid = self.test.data.user[0].uuid
run_method = controller.ProtocolMethods(self.test)
result = run_method._ProtocolMethods__check_auth_token(uuid,
auth_id)
self.assertFalse(result)
def test_add_flow_chat_double_user(self):
self.test.data.flow[0].type = "chat"
self.test.data.user.append(api.User())
self.test.data.user[1].uuid = 1234567
run_method = controller.ProtocolMethods(self.test)
result = json.loads(run_method.get_response())
self.assertEqual(result["errors"]["code"], 200)
async def websocket_endpoint(websocket: WebSocket):
await websocket.accept()
clients.append(websocket)
logger.info("".join(
("Clients information: ", "host: ", str(websocket.client.host),
" port: ", str(websocket.client.port))))
logger.debug(str(websocket.scope))
while True:
try:
data = await websocket.receive_json()
logger.debug(str(data))
client = controller.ProtocolMethods(data)
await websocket.send_bytes(client.get_response())
except WebSocketDisconnect as error:
logger.info("".join(("Disconnection error: ", str(error))))
clients.remove(websocket)
break
except (RuntimeError, JSONDecodeError) as error:
logger.info("".join(("Runtime or Decode error: ", str(error))))
clients.remove(websocket)
break
else:
if websocket.client_state.value == 0:
await websocket.close(code=1000)
clients.remove(websocket)
def test_blank_database(self):
login = self.test.data.user[0].login
dbquery = models.UserConfig.selectBy(login=login).getOne()
dbquery.delete(dbquery.id)
run_method = controller.ProtocolMethods(self.test)
result = json.loads(run_method.get_response())
self.assertEqual(result["errors"]["code"], 404)
def test_write_in_database(self):
login = self.test.data.user[0].login
run_method = controller.ProtocolMethods(self.test)
result = json.loads(run_method.get_response())
dbquery = models.UserConfig.selectBy(login=login).getOne()
self.assertEqual(dbquery.authId,
result["data"]["user"][0]["auth_id"])
def test_check_true_result(self):
uuid = self.test.data.user[0].uuid
auth_id = self.test.data.user[0].auth_id
run_method = controller.ProtocolMethods(self.test)
result = run_method._ProtocolMethods__check_auth_token(uuid,
auth_id)
self.assertTrue(result)
def test_all_flow(self):
models.Flow(flowId=1,
timeCreated=123456,
flowType="flow_type",
title="title",
info="info")
run_method = controller.ProtocolMethods(self.test)
result = json.loads(run_method.get_response())
self.assertEqual(result["data"]["flow"][0]["info"], "info")
def test_two_element_in_database(self):
models.UserConfig(uuid=654321,
login="******",
password="******",
salt=b"salt",
key=b"key")
run_method = controller.ProtocolMethods(self.test)
result = json.loads(run_method.get_response())
self.assertEqual(result["errors"]["code"], 404)
def test_check_delete_message_in_database(self):
controller.ProtocolMethods(self.test)
dbquery = models.Message.selectBy(text="Hello")
self.assertEqual(dbquery.count(), 0)
def test_wrong_password(self):
self.test.data.user[0].password = "******"
run_method = controller.ProtocolMethods(self.test)
result = json.loads(run_method.get_response())
self.assertEqual(result["errors"]["code"], 404)
def test_type_of_key(self):
controller.ProtocolMethods(self.test)
dbquery = models.UserConfig.selectBy(login="******").getOne()
self.assertIsInstance(dbquery.key, bytes)
def test_check_message_in_result(self):
run_method = controller.ProtocolMethods(self.test)
result = json.loads(run_method.get_response())
self.assertEqual(result["data"]["message"][1]["text"],
"Hello2")
def test_write_text_in_database(self):
flow_id = self.test.data.flow[0].id
controller.ProtocolMethods(self.test)
dbquery = models.Message.selectBy(flowID=flow_id).getOne()
self.assertEqual(dbquery.text,
self.test.data.message[0].text)
def test_check_user_info(self):
run_method = controller.ProtocolMethods(self.test)
result = json.loads(run_method.get_response())
self.assertEqual(result["data"]["user"][0]["bio"], "bio")
def test_wrong_flow_id(self):
self.test.data.flow[0].id = 555
run_method = controller.ProtocolMethods(self.test)
result = json.loads(run_method.get_response())
self.assertEqual(result["errors"]["code"], 404)
def test_uuid_write_in_database(self):
run_method = controller.ProtocolMethods(self.test)
result = json.loads(run_method.get_response())
dbquery = models.UserConfig.selectBy(login="******").getOne()
self.assertEqual(dbquery.uuid,
result["data"]["user"][0]["uuid"])
def test_add_flow_chat_single_user(self):
self.test.data.flow[0].type = "chat"
run_method = controller.ProtocolMethods(self.test)
result = json.loads(run_method.get_response())
self.assertEqual(result["errors"]["detail"], "Two users UUID must be specified for chat")
def test_wrong_type_method(self):
self.test = api.ValidJSON.parse_obj(ERRORS)
run_method = controller.ProtocolMethods(self.test)
result = json.loads(run_method.get_response())
self.assertEqual(result["errors"]["code"], 405)
def test_add_flow_bad_type(self):
self.test.data.flow[0].type = "unknown"
run_method = controller.ProtocolMethods(self.test)
result = json.loads(run_method.get_response())
self.assertEqual(result["errors"]["detail"], "Wrong flow type")
def test_add_flow_channel(self):
self.test.data.flow[0].type = "channel"
run_method = controller.ProtocolMethods(self.test)
result = json.loads(run_method.get_response())
self.assertEqual(result["errors"]["code"], 200)
def test_write_time_in_database(self):
flow_id = self.test.data.flow[0].id
controller.ProtocolMethods(self.test)
dbquery = models.Message.selectBy(flowID=flow_id).getOne()
self.assertIsInstance(dbquery.time, int)
def test_new_edited_message(self):
controller.ProtocolMethods(self.test)
dbquery = models.Message.selectBy(id=1).getOne()
self.assertEqual(dbquery.text, "New_Hello")
def test_blank_flow_table_in_database(self):
run_method = controller.ProtocolMethods(self.test)
result = json.loads(run_method.get_response())
self.assertEqual(result["errors"]["code"], 404)
def test_check_message_in_database(self):
controller.ProtocolMethods(self.test)
dbquery = models.Message.selectBy(time=3).getOne()
self.assertEqual(dbquery.text, "Hello2")
def test_no_new_data_in_database(self):
self.test.data.time = 444
run_method = controller.ProtocolMethods(self.test)
result = json.loads(run_method.get_response())
self.assertEqual(result["errors"]["code"], 404)
def test_ping_pong(self):
run_method = controller.ProtocolMethods(self.test)
result = json.loads(run_method.get_response())
self.assertEqual(result["errors"]["code"], 200)
def test_user_write_in_database(self):
controller.ProtocolMethods(self.test)
dbquery = models.UserConfig.selectBy(login="******").getOne()
self.assertEqual(dbquery.login, "login")
def test_unsupported_media_type(self):
self.test = json.dumps(NON_VALID_ERRORS)
run_method = controller.ProtocolMethods(self.test)
result = json.loads(run_method.get_response())
self.assertEqual(result["errors"]["code"], 415)
def test_check_flow_in_database(self):
run_method = controller.ProtocolMethods(self.test)
result = json.loads(run_method.get_response())
dbquery = models.Flow.selectBy(title="title").getOne()
self.assertEqual(dbquery.flowId,
result["data"]["flow"][0]["id"])
