def test_can_get_test_by_correct_ids(self):
user1 = User(0, "LOGIN_USER1", "FN_USER1", "SN_USER1", "MN_USER1", [])
user2 = User(0, "LOGIN_USER2", "FN_USER2", "SN_USER2", "MN_USER2", [])
_, user1 = (self.core.db.addUser(user1))
_, user2 = (self.core.db.addUser(user2))
alg1 = Algorithm(0, "TITLE_ALG1", "DESCR_ALG1", user1.user_id,
"SOURCE_ALG1", [], 0, 0)
alg2 = Algorithm(0, "TITLE_ALG2", "DESCR_ALG2", user1.user_id,
"SOURCE_ALG2", [], 0, 0)
alg3 = Algorithm(0, "TITLE_ALG3", "DESCR_ALG3", user2.user_id,
"SOURCE_ALG3", [], 0, 0)
_, alg1 = (self.core.db.addAlg(alg1))
_, alg2 = (self.core.db.addAlg(alg2))
_, alg3 = (self.core.db.addAlg(alg3))
test1 = Test(0, alg1.alg_id, "TITLE_TEST1", "SOURCE_TEST1")
test2 = Test(0, alg1.alg_id, "TITLE_TEST2", "SOURCE_TEST2")
test3 = Test(0, alg2.alg_id, "TITLE_TEST3", "SOURCE_TEST3")
test4 = Test(0, alg3.alg_id, "TITLE_TEST4", "SOURCE_TEST4")
_, test1 = (self.core.db.addTest(test1))
_, test2 = (self.core.db.addTest(test2))
_, test3 = (self.core.db.addTest(test3))
_, test4 = (self.core.db.addTest(test4))
status1, test5 = self.core.db.getTest(alg1.alg_id, test1.test_id)
status2, test6 = self.core.db.getTest(alg1.alg_id, test2.test_id)
status3, test7 = self.core.db.getTest(alg2.alg_id, test3.test_id)
status4, test8 = self.core.db.getTest(alg3.alg_id, test4.test_id)
self.assertEqual(status1, DBStatus.s_ok)
self.assertEqual(status2, DBStatus.s_ok)
self.assertEqual(status3, DBStatus.s_ok)
self.assertEqual(status4, DBStatus.s_ok)
self.assertEqual(test1, test5)
self.assertEqual(test2, test6)
self.assertEqual(test3, test7)
self.assertEqual(test4, test8)
def test_cant_get_all_alg_tests_by_incorrect_id(self):
user1 = User(0, "LOGIN_USER1", "FN_USER1", "SN_USER1", "MN_USER1", [])
user2 = User(0, "LOGIN_USER2", "FN_USER2", "SN_USER2", "MN_USER2", [])
_, user1 = (self.core.db.addUser(user1))
_, user2 = (self.core.db.addUser(user2))
alg1 = Algorithm(0, "TITLE_ALG1", "DESCR_ALG1", user1.user_id,
"SOURCE_ALG1", [], 0, 0)
alg2 = Algorithm(0, "TITLE_ALG2", "DESCR_ALG2", user1.user_id,
"SOURCE_ALG2", [], 0, 0)
alg3 = Algorithm(0, "TITLE_ALG3", "DESCR_ALG3", user2.user_id,
"SOURCE_ALG3", [], 0, 0)
_, alg1 = (self.core.db.addAlg(alg1))
_, alg2 = (self.core.db.addAlg(alg2))
_, alg3 = (self.core.db.addAlg(alg3))
test1 = Test(0, alg1.alg_id, "TITLE_TEST1", "SOURCE_TEST1")
test2 = Test(0, alg1.alg_id, "TITLE_TEST2", "SOURCE_TEST2")
test3 = Test(0, alg2.alg_id, "TITLE_TEST3", "SOURCE_TEST3")
test4 = Test(0, alg3.alg_id, "TITLE_TEST4", "SOURCE_TEST4")
_, test1 = (self.core.db.addTest(test1))
_, test2 = (self.core.db.addTest(test2))
_, test3 = (self.core.db.addTest(test3))
_, test4 = (self.core.db.addTest(test4))
status1, tests1 = self.core.db.getAllAlgTests(alg1.alg_id +
len("typo"))
status2, tests2 = self.core.db.getAllAlgTests(alg2.alg_id +
len("typo"))
status3, tests3 = self.core.db.getAllAlgTests(alg3.alg_id +
len("typo"))
self.assertEqual(status1, DBStatus.s_data_issue)
self.assertEqual(status2, DBStatus.s_data_issue)
self.assertEqual(status3, DBStatus.s_data_issue)
self.assertEqual(tests1[0].test_id, ERROR_ID)
self.assertEqual(tests2[0].test_id, ERROR_ID)
self.assertEqual(tests3[0].test_id, ERROR_ID)
def test_can_add_diff_tests(self):
user1 = User(0, "LOGIN_USER1", "FN_USER1", "SN_USER1", "MN_USER1", [])
user2 = User(0, "LOGIN_USER2", "FN_USER2", "SN_USER2", "MN_USER2", [])
_, user1 = (self.core.db.addUser(user1))
_, user2 = (self.core.db.addUser(user2))
alg1 = Algorithm(0, "TITLE_ALG1", "DESCR_ALG1", user1.user_id,
"SOURCE_ALG1", [], 0, 0)
alg2 = Algorithm(0, "TITLE_ALG2", "DESCR_ALG2", user1.user_id,
"SOURCE_ALG2", [], 0, 0)
alg3 = Algorithm(0, "TITLE_ALG3", "DESCR_ALG3", user2.user_id,
"SOURCE_ALG3", [], 0, 0)
_, alg1 = (self.core.db.addAlg(alg1))
_, alg2 = (self.core.db.addAlg(alg2))
_, alg3 = (self.core.db.addAlg(alg3))
test1 = Test(0, alg1.alg_id, "TITLE_TEST1", "SOURCE_TEST1")
test2 = Test(0, alg1.alg_id, "TITLE_TEST2", "SOURCE_TEST2")
test3 = Test(0, alg2.alg_id, "TITLE_TEST3", "SOURCE_TEST3")
test4 = Test(0, alg3.alg_id, "TITLE_TEST4", "SOURCE_TEST4")
status1, test1 = self.core.db.addTest(test1)
status2, test2 = self.core.db.addTest(test2)
status3, test3 = self.core.db.addTest(test3)
status4, test4 = self.core.db.addTest(test4)
self.assertEqual(status1, DBStatus.s_ok)
self.assertEqual(status2, DBStatus.s_ok)
self.assertEqual(status3, DBStatus.s_ok)
self.assertEqual(status4, DBStatus.s_ok)
self.assertEqual(test1.test_id, 1)
self.assertEqual(test2.test_id, 2)
self.assertEqual(test3.test_id, 1)
self.assertEqual(test4.test_id, 1)
self.assertEqual(self.core.db._getNextID("1a"), 3)
self.assertEqual(self.core.db._getNextID("2a"), 2)
self.assertEqual(self.core.db._getNextID("3a"), 2)
def test_can_get_stats(self):
user1 = User(0, "LOGIN_USER1", "FN_USER1", "SN_USER1", "MN_USER1", [])
user2 = User(0, "LOGIN_USER2", "FN_USER2", "SN_USER2", "MN_USER2", [])
_, user1 = (self.core.db.addUser(user1))
_, user2 = (self.core.db.addUser(user2))
alg1 = Algorithm(0, "TITLE_ALG1", "DESCR_ALG1", user1.user_id,
"SOURCE_ALG1", [], 0, 0)
alg2 = Algorithm(0, "TITLE_ALG2", "DESCR_ALG2", user1.user_id,
"SOURCE_ALG2", [], 0, 0)
alg3 = Algorithm(0, "TITLE_ALG3", "DESCR_ALG3", user2.user_id,
"SOURCE_ALG3", [], 0, 0)
_, alg1 = (self.core.db.addAlg(alg1))
_, alg2 = (self.core.db.addAlg(alg2))
_, alg3 = (self.core.db.addAlg(alg3))
test1 = Test(0, alg1.alg_id, "TITLE_TEST1", "SOURCE_TEST1")
test2 = Test(0, alg1.alg_id, "TITLE_TEST2", "SOURCE_TEST2")
test3 = Test(0, alg2.alg_id, "TITLE_TEST3", "SOURCE_TEST3")
test4 = Test(0, alg3.alg_id, "TITLE_TEST4", "SOURCE_TEST4")
_, test1 = (self.core.db.addTest(test1))
_, test2 = (self.core.db.addTest(test2))
_, test3 = (self.core.db.addTest(test3))
_, test4 = (self.core.db.addTest(test4))
task1 = Task(0, alg1.alg_id, 0, "MESSAGE_TASK1")
task2 = Task(0, alg2.alg_id, 0, "MESSAGE_TASK2")
task3 = Task(0, alg3.alg_id, 0, "MESSAGE_TASK3")
_, task1 = (self.core.db.addTask(task1))
_, task2 = (self.core.db.addTask(task2))
_, task3 = (self.core.db.addTask(task3))
status, stats = self.core.db.getStats()
self.assertEqual(status, DBStatus.s_ok)
self.assertEqual(stats.num_of_users, 2)
self.assertEqual(stats.num_of_algs, 3)
self.assertEqual(stats.num_of_tests, 4)
self.assertEqual(stats.num_of_tasks, 3)
def addAlg(self, alg) -> Tuple[DBStatus, Algorithm]:
try:
# check user
st, user = self.getUserByID(alg.author_id)
if st == DBStatus.s_data_issue:
logger.error("This user does not exist")
return (DBStatus.s_data_issue, Algorithm(ERROR_ID))
# check title
st, alg_check = self.getAlgByTitle(alg.title)
if st != DBStatus.s_data_issue:
logger.error("This algorithm already exists")
return (DBStatus.s_data_issue, Algorithm(ERROR_ID))
# add alg
algs_collection = self.db["algs"]
alg.alg_id = self._getNextID("algs")
if alg.alg_id == DBStatus.s_data_issue:
return (DBStatus.s_data_issue, Algorithm(ERROR_ID))
if self._insertOneID(str(alg.alg_id) +
"a") == DBStatus.s_data_issue:
return (DBStatus.s_connection_error, Algorithm(ERROR_ID))
algs_collection.insert_one(alg.__dict__)
# update author's list of algs
new_list_algs = user.algs_id
new_list_algs.append(alg.alg_id)
users_collection = self.db["users"]
users_collection.update_one({"user_id": user.user_id},
{"$set": {
"algs_id": new_list_algs
}})
except Exception as e:
logger.error(f"MongoDBWorker connection failed: {e}")
return (DBStatus.s_connection_error, Algorithm(ERROR_ID))
logger.debug("New algorithm was successfully added")
return (DBStatus.s_ok, alg)
def getAlgByID(self, alg_id) -> Tuple[DBStatus, Algorithm]:
try:
algs_collection = self.db["algs"]
alg_d = algs_collection.find_one({"alg_id": alg_id})
if alg_d is None:
logger.error("This algorithm does not exist")
return (DBStatus.s_data_issue, Algorithm(ERROR_ID))
except Exception as e:
logger.error(f"MongoDBWorker connection failed: {e}")
return (DBStatus.s_connection_error, Algorithm(ERROR_ID))
logger.debug("Algorithm was found")
return (DBStatus.s_ok, Algorithm.fromDict(alg_d))
def getAllAlgs(self) -> Tuple[DBStatus, List[Algorithm]]:
try:
algs_collection = self.db["algs"]
algs_tmp = list(algs_collection.find({}))
algs = []
for alg_d in algs_tmp:
algs.append(Algorithm.fromDict(alg_d))
except Exception as e:
logger.error(f"MongoDBWorker connection failed: {e}")
return (DBStatus.s_connection_error, [Algorithm(ERROR_ID)])
logger.debug("Algorithms was found")
return (DBStatus.s_ok, algs)
def testGetAlgsEndpointWithAddedUser(self):
self.core.db.addUser(
User(0, "LOGIN_USER1", "FN_USER1", "SN_USER1", "MN_USER1", []))
alg = Algorithm(0, "algorithm1", "description1", 1, 'print("Hello")',
[], 0, 0)
self.core.db.addAlg(alg)
response = self.client.get('/api/users/')
self.assertEqual(response.status_code, 403)
def testGetAlgByTitleEndpoint(self):
user = User(0, "LOGIN_USER1", "FN_USER1", "SN_USER1", "MN_USER1", [])
self.core.db.addUser(user)
alg = Algorithm(0, "algorithm1", "description1", 1, 'print("Hello")',
[], 0, 0)
self.core.db.addAlg(alg)
response = self.client.get('/api/algs/algorithm1/')
self.assertEqual(response.status_code, 403)
def test_cant_get_algs_by_incorrect_title(self):
user = User(0, "LOGIN_USER", "FN_USER", "SN_USER", "MN_USER", [])
_, user = (self.core.db.addUser(user))
alg1 = Algorithm(0, "TITLE_ALG1", "DESCR_ALG1", user.user_id,
"SOURCE_ALG1", [], 0, 0)
_, alg1 = (self.core.db.addAlg(alg1))
status, alg2 = self.core.db.getAlgByTitle(alg1.title + "typo")
self.assertEqual(status, DBStatus.s_data_issue)
self.assertEqual(alg2.alg_id, ERROR_ID)
def test_can_get_alg_by_correct_title(self):
user = User(0, "LOGIN_USER", "FN_USER", "SN_USER", "MN_USER", [])
_, user = (self.core.db.addUser(user))
alg1 = Algorithm(0, "TITLE_ALG1", "DESCR_ALG1", user.user_id,
"SOURCE_ALG1", [], 0, 0)
_, alg1 = (self.core.db.addAlg(alg1))
status, alg2 = self.core.db.getAlgByTitle(alg1.title)
self.assertEqual(status, DBStatus.s_ok)
self.assertEqual(alg1, alg2)
def test_cant_add_alg_with_incorrect_user_id(self):
user = User(0, "LOGIN_USER", "FN_USER", "SN_USER", "MN_USER", [])
_, user = (self.core.db.addUser(user))
alg = Algorithm(0, "TITLE_ALG", "DESCR_ALG",
user.user_id + len("typo"), "SOURCE_ALG", [], 0, 0)
status, alg = self.core.db.addAlg(alg)
self.assertEqual(status, DBStatus.s_data_issue)
self.assertEqual(alg.alg_id, ERROR_ID)
self.assertEqual(self.core.db._getNextID("1a"), DBStatus.s_data_issue)
def getAllAuthorAlgs(self, author_id) -> Tuple[DBStatus, List[Algorithm]]:
try:
# check user
st, author = self.getUserByID(author_id)
if st == DBStatus.s_data_issue:
logger.error("This user does not exist")
return (DBStatus.s_data_issue, [Algorithm(ERROR_ID)])
# get algs
algs_collection = self.db["algs"]
algs = []
for alg_id in author.algs_id:
alg_d = algs_collection.find_one({
"alg_id": alg_id,
"author_id": author_id
})
algs.append(Algorithm.fromDict(alg_d))
except Exception as e:
logger.error(f"MongoDBWorker connection failed: {e}")
return (DBStatus.s_connection_error, [Algorithm(ERROR_ID)])
logger.debug("Algorithms were found")
return (DBStatus.s_ok, algs)
def test_can_get_all_author_algs_by_correct_user_id(self):
user1 = User(0, "LOGIN_USER1", "FN_USER1", "SN_USER1", "MN_USER1", [])
user2 = User(0, "LOGIN_USER2", "FN_USER2", "SN_USER2", "MN_USER2", [])
_, user1 = (self.core.db.addUser(user1))
_, user2 = (self.core.db.addUser(user2))
alg1 = Algorithm(0, "TITLE_ALG1", "DESCR_ALG1", user1.user_id,
"SOURCE_ALG1", [], 0, 0)
alg2 = Algorithm(0, "TITLE_ALG2", "DESCR_ALG2", user1.user_id,
"SOURCE_ALG2", [], 0, 0)
alg3 = Algorithm(0, "TITLE_ALG3", "DESCR_ALG3", user2.user_id,
"SOURCE_ALG3", [], 0, 0)
_, alg1 = (self.core.db.addAlg(alg1))
_, alg2 = (self.core.db.addAlg(alg2))
_, alg3 = (self.core.db.addAlg(alg3))
status1, algs1 = self.core.db.getAllAuthorAlgs(user1.user_id)
status2, algs2 = self.core.db.getAllAuthorAlgs(user2.user_id)
self.assertEqual(status1, DBStatus.s_ok)
self.assertEqual(status2, DBStatus.s_ok)
self.assertEqual(alg1, algs1[0])
self.assertEqual(alg2, algs1[1])
self.assertEqual(alg3, algs2[0])
def test_cant_get_all_author_algs_by_incorrect_user_id(self):
user1 = User(0, "LOGIN_USER1", "FN_USER1", "SN_USER1", "MN_USER1", [])
user2 = User(0, "LOGIN_USER2", "FN_USER2", "SN_USER2", "MN_USER2", [])
_, user1 = (self.core.db.addUser(user1))
_, user2 = (self.core.db.addUser(user2))
alg1 = Algorithm(0, "TITLE_ALG1", "DESCR_ALG1", user1.user_id,
"SOURCE_ALG1", [], 0, 0)
alg2 = Algorithm(0, "TITLE_ALG2", "DESCR_ALG2", user1.user_id,
"SOURCE_ALG2", [], 0, 0)
alg3 = Algorithm(0, "TITLE_ALG3", "DESCR_ALG3", user2.user_id,
"SOURCE_ALG3", [], 0, 0)
_, alg1 = (self.core.db.addAlg(alg1))
_, alg2 = (self.core.db.addAlg(alg2))
_, alg3 = (self.core.db.addAlg(alg3))
status1, algs1 = self.core.db.getAllAuthorAlgs(user1.user_id +
len("typo"))
status2, algs2 = self.core.db.getAllAuthorAlgs(user2.user_id +
len("typo"))
self.assertEqual(status1, DBStatus.s_data_issue)
self.assertEqual(status2, DBStatus.s_data_issue)
self.assertEqual(algs1[0].alg_id, ERROR_ID)
self.assertEqual(algs2[0].alg_id, ERROR_ID)
def test_can_get_alg_by_correct_alg_id(self):
user1 = User(0, "LOGIN_USER1", "FN_USER1", "SN_USER1", "MN_USER1", [])
user2 = User(0, "LOGIN_USER2", "FN_USER2", "SN_USER2", "MN_USER2", [])
_, user1 = (self.core.db.addUser(user1))
_, user2 = (self.core.db.addUser(user2))
alg1 = Algorithm(0, "TITLE_ALG1", "DESCR_ALG1", user1.user_id,
"SOURCE_ALG1", [], 0, 0)
alg2 = Algorithm(0, "TITLE_ALG2", "DESCR_ALG2", user1.user_id,
"SOURCE_ALG2", [], 0, 0)
alg3 = Algorithm(0, "TITLE_ALG3", "DESCR_ALG3", user2.user_id,
"SOURCE_ALG3", [], 0, 0)
_, alg1 = (self.core.db.addAlg(alg1))
_, alg2 = (self.core.db.addAlg(alg2))
_, alg3 = (self.core.db.addAlg(alg3))
status1, alg4 = self.core.db.getAlgByID(alg1.alg_id)
status2, alg5 = self.core.db.getAlgByID(alg2.alg_id)
status3, alg6 = self.core.db.getAlgByID(alg3.alg_id)
self.assertEqual(status1, DBStatus.s_ok)
self.assertEqual(status2, DBStatus.s_ok)
self.assertEqual(status3, DBStatus.s_ok)
self.assertEqual(alg1, alg4)
self.assertEqual(alg2, alg5)
self.assertEqual(alg3, alg6)
def test_cant_get_alg_by_incorrect_alg_id(self):
user1 = User(0, "LOGIN_USER1", "FN_USER1", "SN_USER1", "MN_USER1", [])
user2 = User(0, "LOGIN_USER2", "FN_USER2", "SN_USER2", "MN_USER2", [])
_, user1 = (self.core.db.addUser(user1))
_, user2 = (self.core.db.addUser(user2))
alg1 = Algorithm(0, "TITLE_ALG1", "DESCR_ALG1", user1.user_id,
"SOURCE_ALG1", [], 0, 0)
alg2 = Algorithm(0, "TITLE_ALG2", "DESCR_ALG2", user1.user_id,
"SOURCE_ALG2", [], 0, 0)
alg3 = Algorithm(0, "TITLE_ALG3", "DESCR_ALG3", user2.user_id,
"SOURCE_ALG3", [], 0, 0)
_, alg1 = (self.core.db.addAlg(alg1))
_, alg2 = (self.core.db.addAlg(alg2))
_, alg3 = (self.core.db.addAlg(alg3))
status1, alg4 = self.core.db.getAlgByID(alg1.alg_id + len("typo"))
status2, alg5 = self.core.db.getAlgByID(alg2.alg_id + len("typo"))
status3, alg6 = self.core.db.getAlgByID(alg3.alg_id + len("typo"))
self.assertEqual(status1, DBStatus.s_data_issue)
self.assertEqual(status2, DBStatus.s_data_issue)
self.assertEqual(status3, DBStatus.s_data_issue)
self.assertEqual(alg4.alg_id, ERROR_ID)
self.assertEqual(alg5.alg_id, ERROR_ID)
self.assertEqual(alg6.alg_id, ERROR_ID)
def test_can_add_diff_algs(self):
user1 = User(0, "LOGIN_USER1", "FN_USER1", "SN_USER1", "MN_USER1", [])
user2 = User(0, "LOGIN_USER2", "FN_USER2", "SN_USER2", "MN_USER2", [])
_, user1 = (self.core.db.addUser(user1))
_, user2 = (self.core.db.addUser(user2))
alg1 = Algorithm(0, "TITLE_ALG1", "DESCR_ALG1", user1.user_id,
"SOURCE_ALG1", [], 0, 0)
alg2 = Algorithm(0, "TITLE_ALG2", "DESCR_ALG2", user1.user_id,
"SOURCE_ALG2", [], 0, 0)
alg3 = Algorithm(0, "TITLE_ALG3", "DESCR_ALG3", user2.user_id,
"SOURCE_ALG3", [], 0, 0)
status1, alg1 = self.core.db.addAlg(alg1)
status2, alg2 = self.core.db.addAlg(alg2)
status3, alg3 = self.core.db.addAlg(alg3)
self.assertEqual(status1, DBStatus.s_ok)
self.assertEqual(status2, DBStatus.s_ok)
self.assertEqual(status3, DBStatus.s_ok)
self.assertEqual(alg1.alg_id, 1)
self.assertEqual(alg2.alg_id, 2)
self.assertEqual(alg3.alg_id, 3)
self.assertEqual(self.core.db._getNextID("1a"), 1)
self.assertEqual(self.core.db._getNextID("2a"), 1)
self.assertEqual(self.core.db._getNextID("3a"), 1)
def test_can_get_all_task(self):
user = User(0, "LOGIN_USER", "FN_USER", "SN_USER", "MN_USER", [])
_, user = (self.core.db.addUser(user))
alg = Algorithm(0, "TITLE_ALG", "DESCR_ALG", user.user_id,
"SOURCE_ALG", [], 0, 0)
_, alg = (self.core.db.addAlg(alg))
task1 = Task(0, alg.alg_id, 0, "MESSAGE_TASK1")
task2 = Task(0, alg.alg_id, 0, "MESSAGE_TASK2")
_, task1 = (self.core.db.addTask(task1))
_, task2 = (self.core.db.addTask(task2))
status, tasks = self.core.db.getAllTasks()
self.assertEqual(status, DBStatus.s_ok)
self.assertEqual(tasks[0], task1)
self.assertEqual(tasks[1], task2)
def test_cant_add_task_with_incorrect_alg_id(self):
user = User(0, "LOGIN_USER", "FN_USER", "SN_USER", "MN_USER", [])
_, user = (self.core.db.addUser(user))
alg = Algorithm(0, "TITLE_ALG", "DESCR_ALG", user.user_id,
"SOURCE_ALG", [], 0, 0)
_, alg = (self.core.db.addAlg(alg))
task1 = Task(0, alg.alg_id + len("typo"), 0, "MESSAGE_TASK1")
task2 = Task(0, alg.alg_id + len("typo"), 0, "MESSAGE_TASK2")
status1, task1 = self.core.db.addTask(task1)
status2, task2 = self.core.db.addTask(task2)
self.assertEqual(status1, DBStatus.s_data_issue)
self.assertEqual(status2, DBStatus.s_data_issue)
self.assertEqual(task1.task_id, ERROR_ID)
self.assertEqual(task2.task_id, ERROR_ID)
self.assertEqual(self.core.db._getNextID("tasks"), 1)
def testGetAlgByTitleEndpoint(self):
user = User(0, "LOGIN_USER1", "FN_USER1", "SN_USER1", "MN_USER1", [])
self.core.db.addUser(user)
alg = Algorithm(0, "algorithm1", "description1", 1, 'print("Hello")',
[], 0, 0)
self.core.db.addAlg(alg)
response = self.client.get('/api/algs/algorithm1/')
self.assertEqual(response.status_code, 200)
stats = response.json()
self.assertEqual(stats["alg_id"], 1)
self.assertEqual(stats["title"], "algorithm1")
self.assertEqual(stats["author_id"], 1)
self.assertEqual(stats["source"], 'print("Hello")')
self.assertEqual(stats["tests_id"], [])
self.assertEqual(stats["lang_id"], 0)
def test_cant_add_iden_tests(self):
user = User(0, "LOGIN_USER", "FN_USER", "SN_USER", "MN_USER", [])
_, user = (self.core.db.addUser(user))
alg = Algorithm(0, "TITLE_ALG", "DESCR_ALG", user.user_id,
"SOURCE_ALG", [], 0, 0)
_, alg = (self.core.db.addAlg(alg))
test1 = Test(0, alg.alg_id, "TITLE_TEST1", "SOURCE_TEST1")
test2 = Test(0, alg.alg_id, "TITLE_TEST1", "SOURCE_TEST2")
status1, test1 = self.core.db.addTest(test1)
status2, test2 = self.core.db.addTest(test2)
self.assertEqual(status1, DBStatus.s_ok)
self.assertEqual(status2, DBStatus.s_data_issue)
self.assertEqual(test1.test_id, 1)
self.assertEqual(test2.test_id, ERROR_ID)
self.assertEqual(self.core.db._getNextID("1a"), 2)
def test_can_get_task_with_correct_id(self):
user = User(0, "LOGIN_USER", "FN_USER", "SN_USER", "MN_USER", [])
_, user = (self.core.db.addUser(user))
alg = Algorithm(0, "TITLE_ALG", "DESCR_ALG", user.user_id,
"SOURCE_ALG", [], 0, 0)
_, alg = (self.core.db.addAlg(alg))
task1 = Task(0, alg.alg_id, 0, "MESSAGE_TASK1")
task2 = Task(0, alg.alg_id, 0, "MESSAGE_TASK2")
_, task1 = (self.core.db.addTask(task1))
_, task2 = (self.core.db.addTask(task2))
status1, task3 = self.core.db.getTask(task1.task_id)
status2, task4 = self.core.db.getTask(task2.task_id)
self.assertEqual(status1, DBStatus.s_ok)
self.assertEqual(status2, DBStatus.s_ok)
self.assertEqual(task1, task3)
self.assertEqual(task2, task4)
