Fixtures for tests

management/data/data_test.py

 from datetime import timedelta
+
 from flask import Flask
 from flask_sqlalchemy import SQLAlchemy
 
 from management.data.shared import DataFactory
-from portal.database.models import Review, Submission, SubmissionState, Secret
+from portal.database.models import Review, Secret, Submission, SubmissionState
 from portal.tools import time
 
 
@@ -19,81 +20,33 @@ def init_test_data(app: Flask, db: SQLAlchemy):
                                        name='Teacher Only', uco=1002)
 
         teacher1.secrets.append(Secret('teacher1_secret', 'ultimate_teacher_secret'))
-        lecturer1 = factory.create_user(
-            username='lecturer1',
-            name='Courses Owner',
-            password='654321',
-            uco=1010
-        )
+        lecturer1 = factory.create_user(username='lecturer1', name='Courses Owner', uco=1010)
 
         # courses
-        test_course1 = factory.create_course(
-            codename='testcourse1', name='Test Course One')
-        test_course2 = factory.create_course(
-            codename='testcourse2', name='test Course Two')
+        test_course1 = factory.create_course(codename='testcourse1', name='Test Course One')
+        test_course2 = factory.create_course(codename='testcourse2', name='test Course Two')
 
         # groups
-        tc1_students = factory.create_group(
-            course=test_course1, name="seminar01")
-        tc1_teachers = factory.create_group(
-            course=test_course1, name="teachers")
-
-        tc2_students = factory.create_group(
-            course=test_course2, name="seminar01")
-        tc2_teachers = factory.create_group(
-            course=test_course2, name="teachers")
-
-        tc1_hw01 = factory.create_project(
-            course=test_course1, name="HW01", codename='hw01', config=dict(
-                file_whitelist="main.cpp",
-                pre_submit_script="python for kontr pre",
-                post_submit_script="python for kontr post",
-                submission_scheduler_config="python for sub Q",
-                submission_parameters="{\"type\":\"text\"}",
-                submissions_allowed_from=time.current_time(),
-                submissions_allowed_to=time.current_time() + timedelta(days=2),
-                archive_from=time.current_time() + timedelta(days=30)
-            )
-        )
-        tc1_hw02 = factory.create_project(
-            course=test_course1, name="HW02", codename='HW02', config=dict(
-                file_whitelist="main.cpp\nfunc.hpp\nfunc.cpp",
-                pre_submit_script="python for kontr pre",
-                post_submit_script="python for kontr post",
-                submission_scheduler_config="python for sub Q",
-                submission_parameters="{\"type\":\"text\"}",
-                submissions_allowed_from=time.current_time() - timedelta(days=1),
-                submissions_allowed_to=time.current_time() + timedelta(days=10),
-                archive_from=time.current_time() + timedelta(days=30)
-            )
-        )
-
-        tc2_hw01 = factory.create_project(
-            course=test_course2, name="HW01", codename='hw01', config=dict(
-                file_whitelist="main.c", pre_submit_script="python for kontr pre",
-                post_submit_script="python for kontr post",
-                submission_scheduler_config="python for sub Q",
-                submission_parameters="{\"type\":\"text\"}",
-                submissions_allowed_from=time.current_time() - timedelta(days=1),
-                submissions_allowed_to=time.current_time() - timedelta(minutes=1),
-                archive_from=time.current_time() + timedelta(days=30)
-            )
-        )
+        tc1_students = factory.create_group(course=test_course1, name="seminar01")
+        tc1_teachers = factory.create_group(course=test_course1, name="teachers")
+
+        tc2_students = factory.create_group(course=test_course2, name="seminar01")
+        tc2_teachers = factory.create_group(course=test_course2, name="teachers")
+
+        tc1_hw01 = factory.scaffold_project(test_course1, 'hw01')
+        tc1_hw02 = factory.scaffold_project(test_course1, 'hw02')
+
+        tc2_hw01 = factory.scaffold_project(test_course2, 'hw01')
+        tc2_hw01 = factory.scaffold_project(test_course2, 'hw02')
 
         # roles
-        tc1_student = factory.scaffold_role(
-            role_type='student', course=test_course1)
-        tc1_teacher = factory.scaffold_role(
-            role_type='teacher', course=test_course1)
-        tc1_owner = factory.scaffold_role(
-            role_type='owner', course=test_course1)
-
-        tc2_student = factory.scaffold_role(
-            role_type='student', course=test_course2)
-        tc2_teacher = factory.scaffold_role(
-            role_type='teacher', course=test_course2)
-        tc2_owner = factory.scaffold_role(
-            role_type='owner', course=test_course2)
+        tc1_student = factory.scaffold_role(role_type='student', course=test_course1)
+        tc1_teacher = factory.scaffold_role(role_type='teacher', course=test_course1)
+        tc1_owner = factory.scaffold_role(role_type='owner', course=test_course1)
+
+        tc2_student = factory.scaffold_role(role_type='student', course=test_course2)
+        tc2_teacher = factory.scaffold_role(role_type='teacher', course=test_course2)
+        tc2_owner = factory.scaffold_role(role_type='owner', course=test_course2)
 
         # relationships
         teacher_student = teacher1
@@ -120,24 +73,18 @@ def init_test_data(app: Flask, db: SQLAlchemy):
         student_both.groups.append(tc2_students)
 
         # submissions
-        tc2_sub1 = Submission(user=teacher_student,
-                              project=tc2_hw01, parameters="")
+        tc2_sub1 = Submission(user=teacher_student, project=tc2_hw01, parameters={})
         tc2_sub1.state = SubmissionState.FINISHED
-        tc2_sub2 = Submission(
-            user=student_both, project=tc2_hw01, parameters="")
+        tc2_sub2 = Submission(user=student_both, project=tc2_hw01, parameters={})
         tc2_sub2.state = SubmissionState.ABORTED
 
-        tc1_sub_p1_cancel = Submission(
-            user=student_both, project=tc1_hw01, parameters="")
+        tc1_sub_p1_cancel = Submission(user=student_both, project=tc1_hw01, parameters={})
         tc1_sub_p1_cancel.state = SubmissionState.CANCELLED
-        tc1_sub_p1_abort = Submission(
-            user=student_tc1, project=tc1_hw01, parameters="")
+        tc1_sub_p1_abort = Submission(user=student_tc1, project=tc1_hw01, parameters={})
         tc1_sub_p1_abort.state = SubmissionState.ABORTED
-        tc1_sub_p1_finished = Submission(
-            user=student_both, project=tc1_hw01, parameters="")
+        tc1_sub_p1_finished = Submission(user=student_both, project=tc1_hw01, parameters={})
         tc1_sub_p1_finished.state = SubmissionState.FINISHED
-        tc1_sub_p1_in_progress = Submission(
-            user=student_tc1, project=tc1_hw01, parameters="")
+        tc1_sub_p1_in_progress = Submission(user=student_tc1, project=tc1_hw01, parameters={})
         tc1_sub_p1_in_progress.state = SubmissionState.IN_PROGRESS
 
         # Projects in groups
@@ -152,10 +99,8 @@ def init_test_data(app: Flask, db: SQLAlchemy):
         review = Review(tc2_sub1)
         factory.create_review_item(author=teacher_both, review=review, line=1,
                                    content="problem here")
-        factory.create_review_item(author=teacher_both, review=review, line=5,
-                                   content="good stuff")
-        factory.create_review_item(author=teacher_student, review=review,
-                                   line=1, content="oops")
+        factory.create_review_item(author=teacher_both, review=review, line=5, content="good stuff")
+        factory.create_review_item(author=teacher_student, review=review, line=1, content="oops")
 
         db.session.add_all([review])
 

tests/conftest.py

@@ -32,7 +32,7 @@ def client(app):
 
 
 @pytest.fixture()
-def rest_service():
+def rest_service(app):
     from portal.service.rest import RestService
     return RestService()
 
@@ -51,3 +51,53 @@ def mocked_submission(ent_mocker: EntitiesMocker, rest_service):
     project_config: ProjectConfig = submission.project.config
     project_config.test_files_commit_hash = 'some-random-hash'
     return submission
+
+
+@pytest.fixture()
+def created_course(rest_service):
+    return rest_service.find.course('testcourse1')
+
+
+@pytest.fixture()
+def created_course2(rest_service):
+    return rest_service.find.course('testcourse2')
+
+
+@pytest.fixture()
+def created_project(rest_service, created_course):
+    return rest_service.find.project(created_course, 'hw01')
+
+
+@pytest.fixture()
+def created_role_student(rest_service, created_course):
+    return rest_service.find.role(created_course, 'student')
+
+
+@pytest.fixture()
+def created_role_teacher(rest_service, created_course):
+    return rest_service.find.role(created_course, 'teacher')
+
+
+@pytest.fixture()
+def created_group(rest_service, created_course):
+    return rest_service.find.group(created_course, 'seminar01')
+
+
+@pytest.fixture()
+def created_student(rest_service):
+    return rest_service.find.user('student1')
+
+
+@pytest.fixture()
+def created_admin(rest_service):
+    return rest_service.find.user('admin')
+
+
+@pytest.fixture()
+def created_teacher(rest_service):
+    return rest_service.find.user('teacher1')
+
+
+@pytest.fixture()
+def created_worker(rest_service):
+    return rest_service.find.worker('executor')

tests/rest/rest_tools.py

-import json
 import json as json_parser
 from datetime import datetime
 
@@ -12,7 +11,7 @@ from portal.database.models import Course, Group, Project, ProjectConfig, Review
 
 
 def get_user_credentials(username, password='123456'):
-    return json.dumps({
+    return json_parser.dumps({
         "type": "username_password",
         "identifier": username,
         "secret": password
@@ -20,7 +19,7 @@ def get_user_credentials(username, password='123456'):
 
 
 def get_user_secret(username, secret):
-    return json.dumps({
+    return json_parser.dumps({
         "type": "secret",
         "identifier": username,
         "secret": secret
@@ -74,7 +73,7 @@ def __get_access_token(client, credentials):
     login_resp = client.post(f"{API_PREFIX}/auth/login", data=credentials,
                              headers={"content-type": "application/json"})
     log.debug(f"[RESP] {login_resp}")
-    resp_data = json.loads(str(login_resp.get_data().decode("utf-8")))
+    resp_data = json_parser.loads(str(login_resp.get_data().decode("utf-8")))
     return resp_data['access_token']
 
 
@@ -272,12 +271,12 @@ def assert_review(expected: Review, actual: dict):
 
 # source:
 # https://stackoverflow.com/questions/11875770/how-to-overcome-datetime-datetime-not-json-serializable
-class DateTimeEncoder(json.JSONEncoder):
+class DateTimeEncoder(json_parser.JSONEncoder):
     def default(self, o):
         if isinstance(o, datetime):
             return o.isoformat()
 
-        return json.JSONEncoder.default(self, o)
+        return json_parser.JSONEncoder.default(self, o)
 
 
 def assert_response(response: flask.Response, code=200, content_type='application/json'):

tests/rest/test_role.py

@@ -3,21 +3,19 @@ from tests.rest.rest_tools import assert_response
 from . import rest_tools
 
 
-def test_list(client):
-    cpp = Course.query.filter_by(codename="testcourse2").first()
-    cpp_roles = len(cpp.roles)
-    response = rest_tools.make_request(client, f'/courses/{cpp.codename}/roles')
+def test_list(client, created_course):
+    cpp_roles = len(created_course.roles)
+    response = rest_tools.make_request(client, f'/courses/{created_course.codename}/roles')
     assert_response(response, 200)
-
     roles = rest_tools.extract_data(response)
     assert len(roles) == cpp_roles
-    cpp_updated = Course.query.filter_by(codename="testcourse1").first()
+    cpp_updated = Course.query.filter_by(codename=created_course.codename).first()
     for r in roles:
         rest_tools.assert_role_in(cpp_updated.roles, r)
 
 
-def test_create(client):
-    cpp = Course.query.filter_by(codename="testcourse1").first()
+def test_create(client, created_course):
+    cpp = created_course
     cpp_roles = len(cpp.roles)
 
     request_dict = {
@@ -25,12 +23,13 @@ def test_create(client):
         'codename': 'new-role',
         "description": "new role desc"
     }
-    response = rest_tools.make_request(client, f"/courses/{cpp.codename}/roles", json=request_dict,
+    url = f"/courses/{created_course.codename}/roles"
+    response = rest_tools.make_request(client, url, json=request_dict,
                                        method='post')
     assert_response(response, 201)
 
     new_role = rest_tools.extract_data(response)
-    cpp_updated = Course.query.filter_by(codename="testcourse1").first()
+    cpp_updated = Course.query.filter_by(codename=created_course.codename).first()
     assert len(cpp_updated.roles) == cpp_roles + 1
     assert new_role['name'] == "new role"
     assert new_role['description'] == "new role desc"
@@ -38,126 +37,105 @@ def test_create(client):
     rest_tools.assert_role_in(cpp_updated.roles, new_role)
 
 
-def test_read(client):
-    cpp = Course.query.filter_by(codename="testcourse1").first()
-    r = cpp.roles[0]
-    response = rest_tools.make_request(
-        client, f"/courses/{cpp.codename}/roles/{r.name}", )
+def test_read(client, created_course, created_role_student):
+    url = f"/courses/{created_course.codename}/roles/{created_role_student.codename}"
+    response = rest_tools.make_request(client, url)
     assert_response(response, 200)
-
     role = rest_tools.extract_data(response)
-
-    rest_tools.assert_role(r, role)
+    rest_tools.assert_role(created_role_student, role)
 
 
-def test_update(client):
-    cpp = Course.query.filter_by(codename="testcourse1").first()
-    r = cpp.roles[0]
-    r_name = r.name
+def test_update(client, created_course, created_role_student, rest_service):
     request_dict = dict(
         name="new role name",
         description="new role desc",
     )
-    response = rest_tools.make_request(client, f"/courses/{cpp.codename}/roles/{r.name}",
-                                       json=request_dict, method='put')
+    url = f"/courses/{created_course.codename}/roles/{created_role_student.name}"
+    response = rest_tools.make_request(client, url, json=request_dict, method='put')
     assert_response(response, 204)
 
-    r_updated = Role.query.filter(Role.course_id == cpp.id).filter(
-        Role.name == "new role name").first()
+    r_updated = rest_service.find.role(created_course, created_role_student.id)
     assert r_updated
     assert r_updated.description == "new role desc"
-    assert not Role.query.filter(Role.course_id == cpp.id).filter(
-        Role.name == r_name).first()
 
 
-def test_delete(client):
-    cpp = Course.query.filter_by(codename="testcourse1").first()
-    r = cpp.roles[0]
-    r_name = r.name
-    cpp_roles = len(cpp.roles)
-    response = rest_tools.make_request(
-        client, f"/courses/{cpp.codename}/roles/{r.name}", method='delete')
+def test_delete(client, created_course, created_role_student, rest_service):
+    cpp_roles = len(created_course.roles)
+    url = f"/courses/{created_course.codename}/roles/{created_role_student.name}"
+    response = rest_tools.make_request(client, url, method='delete')
 
     assert_response(response, 204)
 
-    cpp_updated = Course.query.filter_by(codename="testcourse1").first()
-    assert len(cpp_updated.roles) == cpp_roles - 1
-    assert not Role.query.filter(Role.course_id == cpp.id).filter(
-        Role.name == r_name).first()
+    course_updated = rest_service.find.course(created_course.id)
+    assert len(course_updated.roles) == cpp_roles - 1
+    assert not rest_service.find.role(created_course, created_role_student.id, throws=False)
 
 
-def test_users_list(client):
-    cpp = Course.query.filter_by(codename="testcourse1").first()
-    r = cpp.roles[0]
-    response = rest_tools.make_request(
-        client, f"/courses/{cpp.codename}/roles/{r.id}/clients?type=user", )
+def test_users_list(client, created_course, created_role_student, rest_service):
+    url = f"/courses/{created_course.codename}/roles/{created_role_student.id}/clients?type=user"
+    response = rest_tools.make_request(client, url)
 
     assert_response(response, 200)
 
     users = rest_tools.extract_data(response)
-    assert len(users) == len(r.clients)
+    assert len(users) == len(created_role_student.clients)
     for user in users:
-        rest_tools.assert_user_in(r.clients, user)
+        rest_tools.assert_user_in(created_role_student.clients, user)
 
 
-def test_users_update_add(client):
-    c = Course.query.filter_by(codename="testcourse2").first()
-    roles = [role for role in c.roles if role.name == "student"]
-    r = roles[0]
-    r_users = len(r.clients)
-    user = User.query.filter_by(username="student1").first()
-    assert user not in r.clients
+def test_users_update_add(client, created_course2, created_role_student, rest_service,
+                          created_student):
+    roles = [role for role in created_course2.roles if role.name == "student"]
+    role = roles[0]
+    r_users = len(role.clients)
+    user = created_student
+    assert user not in role.clients
 
-    request_dict = dict(
-        add=[user.id]
-    )
-    response = rest_tools.make_request(client, f"/courses/{c.codename}/roles/{r.name}/clients",
-                                       json=request_dict, method='put')
+    request_dict = dict(add=[user.id])
+    url = f"/courses/{created_course2.codename}/roles/{role.name}/clients"
+    response = rest_tools.make_request(client, url, json=request_dict, method='put')
 
     assert_response(response, 204)
 
-    r_updated = Role.query.filter(
-        Role.course_id == c.id).filter(Role.id == r.id).first()
+    r_updated = rest_service.find.role(created_course2, role.id)
     assert len(r_updated.clients) == r_users + 1
     assert user in r_updated.clients
 
 
-def test_users_update_add_duplicate(client):
-    c = Course.query.filter_by(codename="testcourse2").first()
-    roles = [role for role in c.roles if role.name == "student"]
-    r = roles[0]
-    r_users = len(r.clients)
-    user = r.clients[0]
-    assert user in r.clients
+def test_users_update_add_duplicate(client, created_course2, created_role_student, rest_service,
+                                    created_student):
+    roles = [role for role in created_course2.roles if role.name == "student"]
+    role = roles[0]
+    r_users = len(role.clients)
+    user = role.clients[0]
+    assert user in role.clients
 
     request_dict = dict(add=[user.id])
-    response = rest_tools.make_request(client, f"/courses/{c.codename}/roles/{r.name}/clients",
-                                       json=request_dict, method='put')
+    url = f"/courses/{created_course2.codename}/roles/{role.name}/clients"
+    response = rest_tools.make_request(client, url, json=request_dict, method='put')
 
     assert_response(response, 204)
 
-    r_updated = Role.query.filter(
-        Role.course_id == c.id).filter(Role.id == r.id).first()
+    r_updated = rest_service.find.role(created_course2, role.id)
     assert len(r_updated.clients) == r_users
     assert user in r_updated.clients
 
 
-def test_users_update_remove(client):
-    c = Course.query.filter_by(codename="testcourse2").first()
-    roles = [role for role in c.roles if role.name == "student"]
-    r = roles[0]
-    r_users = len(r.clients)
-    user = r.clients[0]
-    assert user in r.clients
+def test_users_update_remove(client, rest_service, created_course2, created_student):
+    roles = [role for role in created_course2.roles if role.name == "student"]
+    role = roles[0]
+    r_users = len(role.clients)
+    user = role.clients[0]
+    assert user in role.clients
 
     request_dict = dict(remove=[user.id])
-    response = rest_tools.make_request(client, f"/courses/{c.codename}/roles/{r.name}/clients",
+    url = f"/courses/{created_course2.codename}/roles/{role.name}/clients"
+    response = rest_tools.make_request(client, url,
                                        json=request_dict, method='put')
 
     assert_response(response, 204)
 
-    r_updated = Role.query.filter(
-        Role.course_id == c.id).filter(Role.id == r.id).first()
+    r_updated = rest_service.find.role(created_course2, role.id)
     assert len(r_updated.clients) == r_users - 1
     assert user not in r_updated.clients
 

tests/rest/test_worker.py

@@ -30,31 +30,37 @@ def test_create(client):
     rest_tools.assert_worker_in(db_workers, resp_new_worker)
 
 
-def test_read(client):
-    w = Worker.query.filter_by(name="executor").first()
-    response = rest_tools.make_request(client, f"/workers/{w.id}")
+def test_read_by_id(client, created_worker):
+    response = rest_tools.make_request(client, f"/workers/{created_worker.id}")
     assert_response(response)
 
     worker = rest_tools.extract_data(response)
 
-    rest_tools.assert_worker(w, worker)
+    rest_tools.assert_worker(created_worker, worker)
 
 
-def test_update(client):
-    w = Worker.query.filter_by(name="executor").first()
+def test_read_by_codename(client, created_worker):
+    response = rest_tools.make_request(client, f"/workers/{created_worker.codename}")
+    assert_response(response)
+
+    worker = rest_tools.extract_data(response)
+
+    rest_tools.assert_worker(created_worker, worker)
+
+
+def test_update(client, created_worker):
     request_dict = dict(url="new url", portal_secret="such safe")
 
-    response = rest_tools.make_request(client, f'/workers/{w.id}', json=request_dict, method='put')
+    url = f'/workers/{created_worker.id}'
+    response = rest_tools.make_request(client, url, json=request_dict, method='put')
 
     assert_response(response, 204)
-
-    worker_after_update: Worker = Worker.query.filter_by(name="executor").first()
+    worker_after_update: Worker = Worker.query.filter_by(name=created_worker.codename).first()
     assert worker_after_update.url == "new url"
     assert worker_after_update.portal_secret == "such safe"
 
 
-def test_delete(client):
-    worker = Worker.query.filter_by(name="executor").first()
-    response = rest_tools.make_request(client, f'/workers/{worker.id}', method='delete')
+def test_delete(client, created_worker):
+    response = rest_tools.make_request(client, f'/workers/{created_worker.id}', method='delete')
     assert_response(response, 204)
-    assert not Worker.query.filter_by(name="executor").first()
+    assert not Worker.query.filter_by(name=created_worker.codename).first()