From 26235548f31e946faf7b59ac7c7eec89f280be41 Mon Sep 17 00:00:00 2001
From: robbertuittenbroek <robbert.uittenbroek@rijksoverheid.nl>
Date: Fri, 8 Nov 2024 11:40:51 +0100
Subject: [PATCH] Bring code coverage back up and change pre-commit

---
 amt/utils/path.py                             |  12 --
 amt/utils/storage.py                          |  38 ----
 pyproject.toml                                |   4 +-
 tests/api/routes/test_auth.py                 |  11 +
 tests/api/routes/test_project.py              | 192 +++++++++++++++++-
 tests/api/routes/test_projects.py             |  11 +-
 tests/api/test_ai_act_profile.py              |  13 ++
 tests/api/test_deps.py                        |  12 ++
 tests/core/test_authorization.py              |  13 ++
 tests/core/test_db.py                         |   4 +-
 tests/core/test_exception_handlers.py         |  21 +-
 tests/core/test_exceptions.py                 |  19 +-
 tests/e2e/test_move_task.py                   |  70 +++----
 tests/repositories/test_projects.py           | 129 +++++++++++-
 tests/schema/test_schema_group_by_category.py |   7 +
 .../test_schema_publication_category.py       |   7 +
 tests/utils/test_path.py                      |  39 ----
 17 files changed, 460 insertions(+), 142 deletions(-)
 delete mode 100644 amt/utils/path.py
 delete mode 100644 amt/utils/storage.py
 create mode 100644 tests/api/routes/test_auth.py
 create mode 100644 tests/api/test_ai_act_profile.py
 create mode 100644 tests/api/test_deps.py
 create mode 100644 tests/core/test_authorization.py
 create mode 100644 tests/schema/test_schema_group_by_category.py
 create mode 100644 tests/schema/test_schema_publication_category.py
 delete mode 100644 tests/utils/test_path.py

diff --git a/amt/utils/path.py b/amt/utils/path.py
deleted file mode 100644
index 8c7172e1..00000000
--- a/amt/utils/path.py
+++ /dev/null
@@ -1,12 +0,0 @@
-from pathlib import Path
-
-
-def is_safe_path(basedir: Path, path: Path, follow_symlinks: bool = True) -> bool:
-    # Resolve the absolute path of the base directory
-    base = basedir.resolve()
-
-    # Resolve the absolute path of the provided path
-    target = path.resolve() if follow_symlinks else path
-
-    # Check if the target path starts with the base directory path
-    return target.is_relative_to(base) or base == target
diff --git a/amt/utils/storage.py b/amt/utils/storage.py
deleted file mode 100644
index 3ce57190..00000000
--- a/amt/utils/storage.py
+++ /dev/null
@@ -1,38 +0,0 @@
-import logging
-from pathlib import Path
-from typing import Any
-
-from amt.services.storage import StorageFactory
-
-logger = logging.getLogger(__name__)
-
-
-def get_include_content(base_dir: Path, system_card: str, include_name: str, search_key: str) -> dict[str, Any] | None:
-    """
-    Searches for `search_key` in the `include_name` fields in the system card. `include_name` can be `assessments` or
-    `models`.
-    Example:
-        base_dir = /
-        system_card = "system_card.yaml"
-        include_name = "assessments"
-        search_key = "IAMA"
-
-        Suppose the system_card.yaml contains the following:
-            ```
-            assessments:
-                - name: "IAMA"
-                  ...
-                - name: "AIIA"
-            ```
-        Then the function would return the contents of the assessment with name equal to "IAMA".
-
-    """
-    storage_service = StorageFactory.init(storage_type="file", location=base_dir, filename=system_card)
-    system_card_data: Any = storage_service.read()
-
-    for content in system_card_data[include_name]:
-        if search_key.lower() in content["name"].lower():
-            return content
-
-    logger.warning("could not fetch contents")
-    return None
diff --git a/pyproject.toml b/pyproject.toml
index e5e80b8c..9ba93be2 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -115,10 +115,10 @@ relative_files = true # needed for sonarcloud code coverage
 omit = [
     "tests/*"
 ]
-
+concurrency = ["greenlet", "thread"]
 
 [tool.coverage.report]
-fail_under = 75
+fail_under = 95
 
 [tool.coverage.html]
 directory = "htmlcov"
diff --git a/tests/api/routes/test_auth.py b/tests/api/routes/test_auth.py
new file mode 100644
index 00000000..e127fbe2
--- /dev/null
+++ b/tests/api/routes/test_auth.py
@@ -0,0 +1,11 @@
+import pytest
+from httpx import AsyncClient
+from pytest_mock import MockerFixture
+
+
+@pytest.mark.asyncio
+async def test_auth_profile(client: AsyncClient, mocker: MockerFixture) -> None:
+    mocker.patch("amt.api.routes.auth.get_user", return_value="test_user_for_auth_profile")
+    response = await client.get("/auth/profile")
+
+    assert b"https://gravatar.com/" in response.content
diff --git a/tests/api/routes/test_project.py b/tests/api/routes/test_project.py
index 9a6e159b..c992b085 100644
--- a/tests/api/routes/test_project.py
+++ b/tests/api/routes/test_project.py
@@ -1,12 +1,23 @@
 from typing import Any
 
 import pytest
-from amt.api.routes.project import set_path
+from amt.api.routes.project import (
+    MeasureUpdate,
+    find_measure_task,
+    find_requirement_task,
+    find_requirement_tasks_by_measure_urn,
+    get_project_context,
+    get_project_or_error,
+    set_path,
+)
+from amt.core.exceptions import AMTNotFound, AMTRepositoryError
 from amt.models import Project
+from amt.schema.task import MovedTask
 from httpx import AsyncClient
 from pytest_httpx import HTTPXMock
 from pytest_mock import MockFixture
 
+from tests.api.routes.test_projects import MockRequest
 from tests.constants import (
     TASK_REGISTRY_AIIA_CONTENT_PAYLOAD,
     TASK_REGISTRY_CONTENT_PAYLOAD,
@@ -43,6 +54,96 @@ async def test_get_project_tasks(client: AsyncClient, db: DatabaseTestUtils) ->
     assert b"Default Task" in response.content
 
 
+@pytest.mark.asyncio
+async def test_get_project_inference(client: AsyncClient, db: DatabaseTestUtils) -> None:
+    # given
+    await db.given([default_project("testproject1"), default_task(project_id=1, status_id=1)])
+
+    # when
+    response = await client.get("/algorithm-system/1/details/model/inference")
+
+    # then
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "text/html; charset=utf-8"
+    assert b'<button id="runInference"' in response.content
+
+
+@pytest.mark.asyncio
+async def test_move_task(client: AsyncClient, db: DatabaseTestUtils, mocker: MockFixture) -> None:
+    # given
+    await db.given(
+        [
+            default_project("testproject1"),
+            default_task(project_id=1, status_id=1),
+            default_task(project_id=1, status_id=1),
+        ]
+    )
+    mocker.patch("fastapi_csrf_protect.CsrfProtect.validate_csrf", new_callable=mocker.AsyncMock)
+    client.cookies["fastapi-csrf-token"] = "1"
+
+    # All -1 flow
+    move_task_json = MovedTask(taskId=1, statusId=1, previousSiblingId=-1, nextSiblingId=-1).model_dump(by_alias=True)
+    response = await client.patch("/algorithm-system/move_task", json=move_task_json, headers={"X-CSRF-Token": "1"})
+
+    # then
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "text/html; charset=utf-8"
+    assert b"Default Task" in response.content
+
+    # All 1 flow
+    move_task_json = MovedTask(taskId=1, statusId=1, previousSiblingId=1, nextSiblingId=1).model_dump(by_alias=True)
+    response = await client.patch("/algorithm-system/move_task", json=move_task_json, headers={"X-CSRF-Token": "1"})
+
+    # then
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "text/html; charset=utf-8"
+    assert b"Default Task" in response.content
+
+
+@pytest.mark.asyncio
+async def test_get_project_context(client: AsyncClient, db: DatabaseTestUtils, mocker: MockFixture) -> None:
+    # given
+    test_project = default_project_with_system_card("testproject1")
+    project_service = mocker.AsyncMock()
+    project_service.get.return_value = test_project
+
+    project, project_context = await get_project_context(
+        project_id=1, projects_service=project_service, request=MockRequest("nl", url="/")
+    )
+    assert project_context["last_edited"] is None
+    assert project == test_project
+
+
+@pytest.mark.asyncio
+async def test_get_project_non_existing_project(client: AsyncClient, db: DatabaseTestUtils) -> None:
+    # given
+    await db.given([default_project("testproject1"), default_task(project_id=1, status_id=1)])
+
+    # when
+    response = await client.get("/algorithm-system/99/details/tasks")
+
+    # then
+    assert response.status_code == 404
+    assert b"The requested page or resource could not be found." in response.content
+
+
+@pytest.mark.asyncio
+async def test_get_project_or_error(client: AsyncClient, db: DatabaseTestUtils, mocker: MockFixture) -> None:
+    # given
+    test_project = default_project("testproject1")
+    project_service = mocker.AsyncMock()
+    project_service.get.return_value = test_project
+
+    # happy flow
+    project = await get_project_or_error(project_id=1, projects_service=project_service, request=mocker.AsyncMock())
+    assert project == test_project
+
+    # unhappy flow
+    project_service.get.side_effect = AMTRepositoryError
+    with pytest.raises(AMTNotFound):
+        _ = await get_project_or_error(project_id=99, projects_service=project_service, request=mocker.AsyncMock())
+
+
 # TODO: Test are now have hard coded URL paths because the system card
 # is fixed for now. Tests need to be refactored and made proper once
 # the actual stored system card in a project is being rendered.
@@ -364,3 +465,92 @@ def test_set_path():  # type: ignore
     project_dict: dict[str, Any] = {}
     set_path(project_dict, "/root", "value5")
     assert project_dict == {"root": "value5"}
+
+
+@pytest.mark.asyncio
+async def test_find_measure_task() -> None:
+    test_project = default_project_with_system_card("testproject1")
+
+    # no matched measure
+    measure = find_measure_task(test_project.system_card, "")
+    assert measure is None
+
+    # matches measure
+    measure = find_measure_task(test_project.system_card, "urn:nl:ak:mtr:bnd-01")
+    assert measure.urn == "urn:nl:ak:mtr:bnd-01"  # pyright: ignore [reportOptionalMemberAccess]
+    assert measure.value is not None  # pyright: ignore [reportOptionalMemberAccess]
+
+    # no measures in system_card
+    test_project.system_card.measures = []
+    measure = find_measure_task(test_project.system_card, "")
+    assert measure is None
+
+
+@pytest.mark.asyncio
+async def test_find_requirement_task() -> None:
+    test_project = default_project_with_system_card("testproject1")
+
+    # no matched requirement
+    requirement = find_requirement_task(test_project.system_card, "")
+    assert requirement is None
+
+    # matches measure
+    requirement = find_requirement_task(test_project.system_card, "urn:nl:ak:ver:aia-05")
+    assert requirement.urn == "urn:nl:ak:ver:aia-05"  # pyright: ignore [reportOptionalMemberAccess]
+    assert requirement.state is not None  # pyright: ignore [reportOptionalMemberAccess]
+
+    # no measures in system_card
+    test_project.system_card.requirements = []
+    requirement = find_measure_task(test_project.system_card, "")
+    assert requirement is None
+
+
+@pytest.mark.asyncio
+async def test_find_requirement_tasks_by_measure_urn() -> None:
+    test_project = default_project_with_system_card("testproject1")
+
+    # no matched requirement
+    with pytest.raises(IndexError):
+        # TODO: this is because it is not coded well change later
+        requirement_tasks = find_requirement_tasks_by_measure_urn(test_project.system_card, "")
+
+    # matches measure
+    requirement_tasks = find_requirement_tasks_by_measure_urn(test_project.system_card, "urn:nl:ak:mtr:bnd-01")
+    assert len(requirement_tasks) == 3
+
+    # empty requirements
+    test_project.system_card.requirements = []
+    with pytest.raises(KeyError):
+        # TODO: this is because it is not coded well change later
+        requirement_tasks = find_requirement_tasks_by_measure_urn(test_project.system_card, "urn:nl:ak:mtr:bnd-01")
+
+
+@pytest.mark.asyncio
+async def test_get_measure(client: AsyncClient, db: DatabaseTestUtils) -> None:
+    # given
+    await db.given([default_project_with_system_card("testproject1")])
+
+    # when
+    response = await client.get("/algorithm-system/1/measure/urn:nl:ak:mtr:bnd-01")
+
+    # then
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "text/html; charset=utf-8"
+    assert b"Gebruik aselecte steekproeven" in response.content
+
+
+@pytest.mark.asyncio
+async def test_update_measure_value(client: AsyncClient, mocker: MockFixture, db: DatabaseTestUtils) -> None:
+    # given
+    await db.given([default_project_with_system_card("testproject1")])
+    client.cookies["fastapi-csrf-token"] = "1"
+    mocker.patch("fastapi_csrf_protect.CsrfProtect.validate_csrf", new_callable=mocker.AsyncMock)
+
+    # happy flow
+    response = await client.post(
+        "/algorithm-system/1/measure/urn:nl:ak:mtr:bnd-01",
+        json={"measure_update": MeasureUpdate(measure_state="done", measure_value="something").model_dump()},
+        headers={"X-CSRF-Token": "1"},
+    )
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "text/html; charset=utf-8"
diff --git a/tests/api/routes/test_projects.py b/tests/api/routes/test_projects.py
index 2becd077..2591e081 100644
--- a/tests/api/routes/test_projects.py
+++ b/tests/api/routes/test_projects.py
@@ -1,5 +1,6 @@
+from collections.abc import MutableMapping
 from datetime import UTC, datetime
-from typing import cast
+from typing import Any, cast
 
 import pytest
 from amt.api.routes.projects import get_localized_value
@@ -12,6 +13,7 @@
 from fastapi.requests import Request
 from httpx import AsyncClient
 from pytest_mock import MockFixture
+from starlette.datastructures import URL
 
 from tests.constants import default_instrument, default_project
 from tests.database_test_utils import DatabaseTestUtils
@@ -198,8 +200,13 @@ async def test_post_new_projects_write_system_card(
 
 
 class MockRequest(Request):
-    def __init__(self, lang: str) -> None:
+    def __init__(self, lang: str, scope: MutableMapping[str, Any] | None = None, url: str | None = None) -> None:
+        if scope is None:
+            scope = {}
+        if url:
+            self._url = URL(url=url)
         self.lang = lang
+        self.scope = scope
 
     @property
     def headers(self):  # type: ignore
diff --git a/tests/api/test_ai_act_profile.py b/tests/api/test_ai_act_profile.py
new file mode 100644
index 00000000..d876679d
--- /dev/null
+++ b/tests/api/test_ai_act_profile.py
@@ -0,0 +1,13 @@
+from amt.api.ai_act_profile import (
+    AiActProfileItem,
+    get_translation,
+)
+from babel.support import Translations
+
+
+def test_get_translation():
+    translation = Translations.load("amt/locale", locales="en")
+    for item in AiActProfileItem:
+        assert get_translation(item, translation) is not None
+    # empty match
+    assert get_translation(None, translation) is None  # pyright: ignore
diff --git a/tests/api/test_deps.py b/tests/api/test_deps.py
new file mode 100644
index 00000000..e46688a9
--- /dev/null
+++ b/tests/api/test_deps.py
@@ -0,0 +1,12 @@
+from amt.api.deps import custom_context_processor
+
+from tests.constants import default_fastapi_request
+
+
+def test_custom_context_processor():
+    result = custom_context_processor(default_fastapi_request())
+    assert result is not None
+    assert result["version"] == "0.1.0"
+    assert result["available_translations"] == ["en", "nl"]
+    assert result["language"] == "en"
+    assert result["translations"] is None
diff --git a/tests/core/test_authorization.py b/tests/core/test_authorization.py
new file mode 100644
index 00000000..5a8e7cf4
--- /dev/null
+++ b/tests/core/test_authorization.py
@@ -0,0 +1,13 @@
+import pytest
+from amt.core.authorization import get_user
+from pytest_mock import MockerFixture
+
+
+@pytest.mark.asyncio
+def test_get_user(mocker: MockerFixture) -> None:
+    mock_request = mocker.Mock(scope=["session"])
+    mock_request.session = {"user": {"name": "user"}}
+    mock_get_requested_language = mocker.patch("amt.core.authorization.get_requested_language", return_value="nl")
+    user = get_user(mock_request)
+    assert user == {"name": "user", "locale": "nl"}
+    mock_get_requested_language.assert_called_once_with(mock_request)
diff --git a/tests/core/test_db.py b/tests/core/test_db.py
index 43442e81..d1657d75 100644
--- a/tests/core/test_db.py
+++ b/tests/core/test_db.py
@@ -4,6 +4,7 @@
 import pytest
 from amt.core.db import (
     check_db,
+    init_db,
 )
 from pytest_mock import MockFixture
 from sqlalchemy import select
@@ -13,12 +14,13 @@
 
 
 @pytest.mark.asyncio
-async def test_check_database(monkeypatch: pytest.MonkeyPatch, tmp_path: Path, mocker: MockFixture):
+async def test_check_and_init_database(monkeypatch: pytest.MonkeyPatch, tmp_path: Path, mocker: MockFixture):
     database_file = tmp_path / "database.sqlite3"
     monkeypatch.setenv("APP_DATABASE_FILE", str(database_file))
     org_exec = AsyncSession.execute
     AsyncSession.execute = mocker.AsyncMock()
     await check_db()
+    await init_db()
 
     assert AsyncSession.execute.call_args is not None
     assert str(select(1)) == str(AsyncSession.execute.call_args.args[0])
diff --git a/tests/core/test_exception_handlers.py b/tests/core/test_exception_handlers.py
index c75fb73e..958d746f 100644
--- a/tests/core/test_exception_handlers.py
+++ b/tests/core/test_exception_handlers.py
@@ -1,10 +1,13 @@
 import pytest
+from amt.core.exception_handlers import translate_pydantic_exception
 from amt.core.exceptions import AMTCSRFProtectError
 from amt.schema.project import ProjectNew
+from babel.support import NullTranslations
 from fastapi import status
 from httpx import AsyncClient
 
 
+@pytest.mark.asyncio
 async def test_http_exception_handler(client: AsyncClient):
     response = await client.get("/raise-http-exception")
 
@@ -12,6 +15,7 @@ async def test_http_exception_handler(client: AsyncClient):
     assert response.headers["content-type"] == "text/html; charset=utf-8"
 
 
+@pytest.mark.asyncio
 async def test_request_validation_exception_handler(client: AsyncClient):
     response = await client.get("/algorithm-systems/?skip=a")
 
@@ -19,15 +23,17 @@ async def test_request_validation_exception_handler(client: AsyncClient):
     assert response.headers["content-type"] == "text/html; charset=utf-8"
 
 
+@pytest.mark.asyncio
 async def test_request_csrf_protect_exception_handler_invalid_token_in_header(client: AsyncClient):
     data = await client.get("/algorithm-systems/new")
     new_project = ProjectNew(name="default project", lifecycle="DATA_EXPLORATION_AND_PREPARATION")
     with pytest.raises(AMTCSRFProtectError):
-        _response = client.post(
+        _response = await client.post(
             "/algorithm-systems/new", json=new_project.model_dump(), headers={"X-CSRF-Token": "1"}, cookies=data.cookies
         )
 
 
+@pytest.mark.asyncio
 async def test_http_exception_handler_htmx(client: AsyncClient):
     response = await client.get("/raise-http-exception", headers={"HX-Request": "true"})
 
@@ -35,6 +41,7 @@ async def test_http_exception_handler_htmx(client: AsyncClient):
     assert response.headers["content-type"] == "text/html; charset=utf-8"
 
 
+@pytest.mark.asyncio
 async def test_request_validation_exception_handler_htmx(client: AsyncClient):
     response = await client.get("/algorithm-systems/?skip=a", headers={"HX-Request": "true"})
 
@@ -42,11 +49,12 @@ async def test_request_validation_exception_handler_htmx(client: AsyncClient):
     assert response.headers["content-type"] == "text/html; charset=utf-8"
 
 
+@pytest.mark.asyncio
 async def test_request_csrf_protect_exception_handler_invalid_token(client: AsyncClient):
     data = await client.get("/algorithm-systems/new")
     new_project = ProjectNew(name="default project", lifecycle="DATA_EXPLORATION_AND_PREPARATION")
     with pytest.raises(AMTCSRFProtectError):
-        _response = client.post(
+        _response = await client.post(
             "/algorithm-systems/new",
             json=new_project.model_dump(),
             headers={"HX-Request": "true", "X-CSRF-Token": "1"},
@@ -54,8 +62,7 @@ async def test_request_csrf_protect_exception_handler_invalid_token(client: Asyn
         )
 
 
-async def test_(client: AsyncClient):
-    response = await client.get("/algorithm-systems/?skip=a", headers={"HX-Request": "true"})
-
-    assert response.status_code == status.HTTP_400_BAD_REQUEST
-    assert response.headers["content-type"] == "text/html; charset=utf-8"
+@pytest.mark.asyncio
+async def test_translate_pydantic_exception(client: AsyncClient) -> None:
+    response = translate_pydantic_exception(err={"msg": "test", "type": "nonexistent"}, translations=NullTranslations())
+    assert response == "test"
diff --git a/tests/core/test_exceptions.py b/tests/core/test_exceptions.py
index 81e59b4f..3db035b9 100644
--- a/tests/core/test_exceptions.py
+++ b/tests/core/test_exceptions.py
@@ -1,5 +1,7 @@
+from gettext import NullTranslations
+
 import pytest
-from amt.core.exceptions import AMTInstrumentError, AMTNotFound, AMTSettingsError
+from amt.core.exceptions import AMTCSRFProtectError, AMTError, AMTInstrumentError, AMTNotFound, AMTSettingsError
 
 
 def test_settings_error():
@@ -27,3 +29,18 @@ def test_RepositoryNoResultFound():
         exc_info.value.detail
         == "The requested page or resource could not be found. Please check the URL or query and try again."
     )
+
+
+def test_AMTError():
+    e = AMTError()
+    e.detail = "test"  # pyright: ignore [reportAttributeAccessIssue]
+    res = e.getmessage(NullTranslations())  # pyright: ignore [reportArgumentType]
+
+    assert res == "test"
+
+
+def test_AMTCSRFProtectError():
+    with pytest.raises(AMTCSRFProtectError) as exc_info:
+        raise AMTCSRFProtectError()
+
+    assert exc_info.value.detail == "CSRF check failed."
diff --git a/tests/e2e/test_move_task.py b/tests/e2e/test_move_task.py
index b8a85553..36929bfe 100644
--- a/tests/e2e/test_move_task.py
+++ b/tests/e2e/test_move_task.py
@@ -1,4 +1,3 @@
-# ruff: noqa
 import pytest
 from playwright.sync_api import Page, expect
 
@@ -30,39 +29,36 @@ def test_e2e_move_task_to_column(page: Page) -> None:
     page.drag_and_drop("#card-container-1", "#column-1", target_position={"x": 50, "y": 50})
 
 
-# TODO: FIX THIS WITH ROBBERT
-# @pytest.mark.slow
-# def test_e2e_move_task_order_in_same_column(page: Page) -> None:
-#     """
-#     Test moving a task in the page below another task and verify that after a reload
-#     it is in the right position in the column.
-#     :return: None
-#     """
-#
-#     page.goto("/project/1/details/tasks")
-#
-#     card1 = page.get_by_text("task1")
-#     card2 = page.get_by_text("task2")
-#     card3 = page.get_by_text("task3")
-#
-#     expect(card1).to_be_visible()
-#     expect(card2).to_be_visible()
-#     expect(card3).to_be_visible()
-#
-#     source = page.locator("#card-container-1")
-#     target = page.locator("#card-container-3")
-#     # with page.expect_response("/project/move_task") as response_info:
-#     page.drag_and_drop("#card-container-1", "#card-container-3", target_position={"x": 1, "y": 1})
-#
-#     # response = response_info.value
-#     # assert response.status == 200
-#
-#     page.reload()
-#
-#     tasks_in_column = page.locator("#column-1").locator(".progress-card-container").all()
-#
-#     expect(tasks_in_column[0]).to_have_id("card-container-2")
-#     expect(tasks_in_column[1]).to_have_id("card-container-3")
-#     expect(tasks_in_column[2]).to_have_id("card-container-1")
-#
-#     card1.drag_to(target=card2)
+@pytest.mark.slow
+def test_e2e_move_task_order_in_same_column(page: Page) -> None:
+    """
+    Test moving a task in the page below another task and verify that after a reload
+    it is in the right position in the column.
+    :return: None
+    """
+
+    page.goto("/algorithm-system/1/details/tasks")
+
+    card1 = page.get_by_text("task1")
+    card2 = page.get_by_text("task2")
+    card3 = page.get_by_text("task3")
+
+    expect(card1).to_be_visible()
+    expect(card2).to_be_visible()
+    expect(card3).to_be_visible()
+
+    page.locator("#card-container-1").hover()
+    page.mouse.down()
+    # when we move the mouse like below, the mouse move is triggered correctly,
+    #  just hover doesn't work for unknown reason
+    page.mouse.move(x=10, y=10)
+    page.locator("#card-container-3").hover(position={"x": 10, "y": 50})
+    page.mouse.up()
+
+    page.reload()
+
+    tasks_in_column = page.locator("#column-1").locator(".progress-card-container").all()
+
+    expect(tasks_in_column[0]).to_have_id("card-container-2")
+    expect(tasks_in_column[1]).to_have_id("card-container-3")
+    expect(tasks_in_column[2]).to_have_id("card-container-1")
diff --git a/tests/repositories/test_projects.py b/tests/repositories/test_projects.py
index 5d02aebb..648dcd33 100644
--- a/tests/repositories/test_projects.py
+++ b/tests/repositories/test_projects.py
@@ -1,8 +1,10 @@
 import pytest
+from amt.api.lifecycles import Lifecycles
+from amt.api.publication_category import PublicationCategories
 from amt.core.exceptions import AMTRepositoryError
 from amt.models import Project
-from amt.repositories.projects import ProjectsRepository
-from tests.constants import default_project
+from amt.repositories.projects import ProjectsRepository, sort_by_lifecycle, sort_by_lifecycle_reversed
+from tests.constants import default_project, default_project_with_lifecycle, default_project_with_system_card
 from tests.database_test_utils import DatabaseTestUtils
 
 
@@ -182,3 +184,126 @@ async def test_raises_exception(db: DatabaseTestUtils):
 
     with pytest.raises(AMTRepositoryError):
         await project_repository.paginate(skip="a", limit=3, search="", filters={}, sort={})  # type: ignore
+
+
+@pytest.mark.asyncio
+async def test_sort_by_lifecyle(db: DatabaseTestUtils):
+    await db.given(
+        [
+            default_project_with_lifecycle(name="Project1", lifecycle=Lifecycles.DESIGN),
+            default_project(name="Project2"),
+        ]
+    )
+    project_repository = ProjectsRepository(db.get_session())
+
+    projects: list[Project] = await project_repository.paginate(skip=0, limit=4, search="", filters={}, sort={})
+    result = sort_by_lifecycle(projects[0])
+    assert result == 2
+
+    result = sort_by_lifecycle(projects[1])
+    assert result == -1
+
+
+@pytest.mark.asyncio
+async def test_sort_by_lifecycle_reversed(db: DatabaseTestUtils):
+    await db.given(
+        [
+            default_project_with_lifecycle(name="Project1", lifecycle=Lifecycles.DESIGN),
+            default_project(name="Project2"),
+        ]
+    )
+    project_repository = ProjectsRepository(db.get_session())
+
+    projects: list[Project] = await project_repository.paginate(skip=0, limit=4, search="", filters={}, sort={})
+    result = sort_by_lifecycle_reversed(projects[0])
+    assert result == -2
+
+    result = sort_by_lifecycle_reversed(projects[1])
+    assert result == 1
+
+
+@pytest.mark.asyncio
+async def test_with_lifecycle_filter(db: DatabaseTestUtils):
+    await db.given(
+        [
+            default_project_with_lifecycle(name="Project1"),
+            default_project(name="Project2"),
+            default_project(name="Project3"),
+            default_project(name="Project4"),
+        ]
+    )
+    project_repository = ProjectsRepository(db.get_session())
+
+    result: list[Project] = await project_repository.paginate(
+        skip=0, limit=4, search="", filters={"lifecycle": Lifecycles.DESIGN.name}, sort={}
+    )
+
+    assert len(result) == 1
+    assert result[0].name == "Project1"
+
+
+@pytest.mark.asyncio
+async def test_with_publication_category_filter(db: DatabaseTestUtils):
+    await db.given(
+        [
+            default_project_with_system_card(name="Project1"),
+            default_project(name="Project2"),
+            default_project(name="Project3"),
+            default_project(name="Project4"),
+        ]
+    )
+    project_repository = ProjectsRepository(db.get_session())
+
+    result: list[Project] = await project_repository.paginate(
+        skip=0, limit=4, search="", filters={"publication-category": PublicationCategories.HOOG_RISICO_AI.name}, sort={}
+    )
+
+    assert len(result) == 1
+    assert result[0].name == "Project1"
+
+
+@pytest.mark.asyncio
+async def test_with_sorting(db: DatabaseTestUtils):
+    await db.given(
+        [
+            default_project_with_lifecycle(name="Project1", lifecycle=Lifecycles.DESIGN),
+            default_project_with_lifecycle(name="Project2", lifecycle=Lifecycles.PHASING_OUT),
+        ]
+    )
+    project_repository = ProjectsRepository(db.get_session())
+
+    # Sort name Ascending
+    result: list[Project] = await project_repository.paginate(
+        skip=0, limit=4, search="", filters={}, sort={"name": "ascending"}
+    )
+    assert result[0].name == "Project1"
+
+    # Sort name Descending
+    result: list[Project] = await project_repository.paginate(
+        skip=0, limit=4, search="", filters={}, sort={"name": "descending"}
+    )
+    assert result[0].name == "Project2"
+
+    # Sort last_update Ascending
+    result: list[Project] = await project_repository.paginate(
+        skip=0, limit=4, search="", filters={}, sort={"last_update": "ascending"}
+    )
+    assert result[0].name == "Project1"
+
+    # Sort last_update Descending
+    result: list[Project] = await project_repository.paginate(
+        skip=0, limit=4, search="", filters={}, sort={"last_update": "descending"}
+    )
+    assert result[0].name == "Project1"
+
+    # Sort lifecycle regular
+    result: list[Project] = await project_repository.paginate(
+        skip=0, limit=4, search="", filters={}, sort={"lifecycle": "ascending"}
+    )
+    assert result[0].name == "Project1"
+
+    # Sort lifecycle reversed
+    result: list[Project] = await project_repository.paginate(
+        skip=0, limit=4, search="", filters={}, sort={"lifecycle": "descending"}
+    )
+    assert result[0].name == "Project2"
diff --git a/tests/schema/test_schema_group_by_category.py b/tests/schema/test_schema_group_by_category.py
new file mode 100644
index 00000000..ca7ce159
--- /dev/null
+++ b/tests/schema/test_schema_group_by_category.py
@@ -0,0 +1,7 @@
+from amt.schema.group_by_category import GroupByCategory
+
+
+def test_group_by_category():
+    group_by_category = GroupByCategory(id="1", name="test")
+    assert group_by_category.id == "1"
+    assert group_by_category.name == "test"
diff --git a/tests/schema/test_schema_publication_category.py b/tests/schema/test_schema_publication_category.py
new file mode 100644
index 00000000..6ff17ce4
--- /dev/null
+++ b/tests/schema/test_schema_publication_category.py
@@ -0,0 +1,7 @@
+from amt.schema.publication_category import PublicationCategory
+
+
+def test_publication_category():
+    publication_category = PublicationCategory(id="1", name="test")
+    assert publication_category.id == "1"
+    assert publication_category.name == "test"
diff --git a/tests/utils/test_path.py b/tests/utils/test_path.py
deleted file mode 100644
index df5b1ce0..00000000
--- a/tests/utils/test_path.py
+++ /dev/null
@@ -1,39 +0,0 @@
-from pathlib import Path
-
-from amt.utils.path import is_safe_path
-
-
-def test_utils_path_is_safe_path():
-    # given
-    basedir = Path("/test/")
-    path = Path("/test/") / "test.yaml"
-
-    # when
-    result = is_safe_path(basedir, path)
-
-    # then
-    assert result is True
-
-
-def test_utils_path_is_not_safe_path():
-    # given
-    basedir = Path("/test/")
-    path = Path("/test/") / "../test.yaml"
-
-    # when
-    result = is_safe_path(basedir, path)
-
-    # then
-    assert result is False
-
-
-def test_utils_path_is_same_safe_path():
-    # given
-    basedir = Path("/test/")
-    path = Path("/test/")
-
-    # when
-    result = is_safe_path(basedir, path)
-
-    # then
-    assert result is True