update unit test for coverage

src/server/messages/error.py

@@ -657,7 +657,7 @@
 
 FAILED_CREATE_FILE_RECORD = LogMessage(
     "E620",
-    "Failed to create file record for file (id: %(file_id)s) in database.",
+    "Failed to create file record for file (path: %(file_path)s) in database.",
 )
 
 INVALID_FILE_STRUCTURE = LogMessage(

tests/unit/api/test_search.py

@@ -0,0 +1,52 @@
+import inspect
+
+from flask import Flask
+from pytest_mock import MockerFixture
+
+from server.api import search as search_api
+from server.api.schemas import ErrorResponse, GlobalSearchQuery, GlobalSearchResult
+from server.entities.search_request import SearchResult
+from server.exc import InvalidQueryError
+
+
+def test_get_success(app: Flask, mocker: MockerFixture) -> None:
+    query = GlobalSearchQuery(q="test", l=10)
+    excepted_status = 200
+    result_repo = SearchResult(total=1, page_size=10, offset=0, resources=[])
+    result_group = SearchResult(total=2, page_size=10, offset=0, resources=[])
+    result_user = SearchResult(total=3, page_size=10, offset=0, resources=[])
+    mocker.patch("server.services.repositories.search", return_value=result_repo)
+    mocker.patch("server.services.groups.search", return_value=result_group)
+    mocker.patch("server.services.users.search", return_value=result_user)
+    original_func = inspect.unwrap(search_api.get)
+    resp, status = original_func(query)
+    assert status == excepted_status
+    assert isinstance(resp, GlobalSearchResult)
+
+
+def test_get_partial_invalid_query_error(app: Flask, mocker: MockerFixture) -> None:
+    query = GlobalSearchQuery(q="test", l=10)
+    excepted_status = 200
+
+    result_repo = SearchResult(total=1, page_size=10, offset=0, resources=[])
+    mocker.patch("server.services.repositories.search", return_value=result_repo)
+    mocker.patch("server.services.groups.search", side_effect=InvalidQueryError("fail"))
+    result_user = SearchResult(total=3, page_size=10, offset=0, resources=[])
+    mocker.patch("server.services.users.search", return_value=result_user)
+    original_func = inspect.unwrap(search_api.get)
+    resp, status = original_func(query)
+    assert status == excepted_status
+    assert isinstance(resp, GlobalSearchResult)
+
+
+def test_get_all_invalid_query_error(app: Flask, mocker: MockerFixture) -> None:
+    query = GlobalSearchQuery(q="test", l=10)
+    excepted_status = 400
+    mocker.patch("server.services.repositories.search", side_effect=InvalidQueryError("fail"))
+    mocker.patch("server.services.groups.search", side_effect=InvalidQueryError("fail"))
+    mocker.patch("server.services.users.search", side_effect=InvalidQueryError("fail"))
+    original_func = inspect.unwrap(search_api.get)
+    resp, status = original_func(query)
+    assert status == excepted_status
+    assert isinstance(resp, ErrorResponse)
+    assert resp.message == "Failed to get search results"

tests/unit/api/test_users.py

@@ -10,7 +10,7 @@
 from server.entities.login_user import LoginUser
 from server.entities.search_request import SearchResult
 from server.entities.user_detail import RepositoryRole, UserDetail
-from server.exc import InvalidFormError, InvalidQueryError, ResourceInvalid, ResourceNotFound
+from server.exc import InvalidExportError, InvalidFormError, InvalidQueryError, ResourceInvalid, ResourceNotFound
 from server.messages import E
 
 
@@ -286,36 +286,6 @@ def test_id_put_invalid_form_error_400(app: Flask, mocker: MockerFixture) -> Non
     assert result == expected_result
 
 
-def test_id_put_sys_exc_info_branch(app: Flask, mocker: MockerFixture):
-    """Covers id_put: sys.exc_info()[0] is not None -> traceback.print_exc() branch (without raising exception)."""
-    expected_status = 200
-    user = UserDetail(
-        id="dummy",
-        user_name="user20",
-        emails=["user20@example.com"],
-        eppns=["eppn20"],
-        preferred_language="en",
-        repository_roles=[RepositoryRole(id="repo20", user_role=USER_ROLES.REPOSITORY_ADMIN)],
-        is_system_admin=False,
-    )
-    dummy_user = LoginUser(
-        eppn="dummy",
-        is_member_of="",
-        user_name="dummy",
-        map_id="not_u20",
-        session_id="dummy",
-    )
-    mocker.patch("server.api.users.current_user", dummy_user)
-    mocker.patch("server.services.users.update", return_value=user)
-    mocker.patch("sys.exc_info", return_value=(Exception, None, None))
-    print_exc_mock = mocker.patch("traceback.print_exc")
-    original_func = inspect.unwrap(users_api.id_put)
-    result, status = original_func("u20", user)
-    assert result == user
-    assert status == expected_status
-    assert print_exc_mock.called
-
-
 def test_id_put_not_found(app: Flask, mocker: MockerFixture) -> None:
     """Tests id_put returns ErrorResponse and 404 when user not found."""
 
@@ -379,6 +349,36 @@ def test_id_put_resource_invalid(app: Flask, mocker: MockerFixture) -> None:
     assert not result.message
 
 
+def test_id_put_sys_exc_info_branch(app: Flask, mocker: MockerFixture):
+    """Covers id_put: sys.exc_info()[0] is not None -> traceback.print_exc() branch (without raising exception)."""
+    expected_status = 200
+    user = UserDetail(
+        id="dummy",
+        user_name="user20",
+        emails=["user20@example.com"],
+        eppns=["eppn20"],
+        preferred_language="en",
+        repository_roles=[RepositoryRole(id="repo20", user_role=USER_ROLES.REPOSITORY_ADMIN)],
+        is_system_admin=False,
+    )
+    dummy_user = LoginUser(
+        eppn="dummy",
+        is_member_of="",
+        user_name="dummy",
+        map_id="not_u20",
+        session_id="dummy",
+    )
+    mocker.patch("server.api.users.current_user", dummy_user)
+    mocker.patch("server.services.users.update", return_value=user)
+    mocker.patch("sys.exc_info", return_value=(Exception, None, None))
+    print_exc_mock = mocker.patch("traceback.print_exc")
+    original_func = inspect.unwrap(users_api.id_put)
+    result, status = original_func("u20", user)
+    assert result == user
+    assert status == expected_status
+    assert print_exc_mock.called
+
+
 def test_has_permission_system_admin(mocker: MockerFixture) -> None:
     """Tests has_permission returns True for system admin."""
     user = UserDetail(
@@ -436,3 +436,62 @@ def test_filter_options_returns_search_users_options_unit(mocker: MockerFixture)
 
     result = original_func()
     assert result == mock_return
+
+
+def test_export_get_success(app, mocker: MockerFixture) -> None:
+
+    query = {"foo": "bar"}
+    mock_current_user = mocker.patch("server.api.users.current_user")
+    mock_current_user.map_id = "mapid"
+    mock_current_user.name = "username"
+    mock_file = object()
+    mocker.patch("server.api.users.users.make_export_file", return_value=mock_file)
+    mock_send_file = mocker.patch("server.api.users.send_file", return_value="sent-file-response")
+    original_func = inspect.unwrap(users_api.export_get)
+    with app.test_request_context():
+        resp = original_func(query)
+    mock_send_file.assert_called_once_with(mock_file)
+    assert resp == "sent-file-response"
+
+
+def test_export_get_invalid_export_error(app, mocker: MockerFixture) -> None:
+    excepted_status = 403
+    query = {"foo": "bar"}
+    mock_current_user = mocker.patch("server.api.users.current_user")
+    mock_current_user.map_id = "mapid"
+    mock_current_user.name = "username"
+    mocker.patch("server.api.users.users.make_export_file", side_effect=InvalidExportError("failmsg"))
+    original_func = inspect.unwrap(users_api.export_get)
+    with app.test_request_context():
+        result, state = original_func(query)
+    assert state == excepted_status
+    assert isinstance(result, ErrorResponse)
+
+
+def test_export_post_success(app, mocker: MockerFixture) -> None:
+    query = {"foo": "bar"}
+    mock_current_user = mocker.patch("server.api.users.current_user")
+    mock_current_user.map_id = "mapid"
+    mock_current_user.name = "username"
+    mock_file = object()
+    mocker.patch("server.api.users.users.make_export_file", return_value=mock_file)
+    mock_send_file = mocker.patch("server.api.users.send_file", return_value="sent-file-response")
+    original_func = inspect.unwrap(users_api.export_post)
+    with app.test_request_context():
+        resp = original_func(query)
+    mock_send_file.assert_called_once_with(mock_file)
+    assert resp == "sent-file-response"
+
+
+def test_export_post_invalid_export_error(app, mocker: MockerFixture) -> None:
+    excepted_status = 403
+    query = {"foo": "bar"}
+    mock_current_user = mocker.patch("server.api.users.current_user")
+    mock_current_user.map_id = "mapid"
+    mock_current_user.name = "username"
+    mocker.patch("server.api.users.users.make_export_file", side_effect=InvalidExportError("failmsg"))
+    original_func = inspect.unwrap(users_api.export_post)
+    with app.test_request_context():
+        result, state = original_func(query)
+    assert state == excepted_status
+    assert isinstance(result, ErrorResponse)

tests/unit/cli/test_app.py

@@ -0,0 +1,15 @@
+from click.testing import CliRunner
+
+from server.cli.app import version
+
+
+def test_version_logs_version_(app, mocker):
+    fake_version = "9.9.9"
+    fake_pyproject = {"project": {"version": fake_version}}
+    mocker.patch("tomllib.load", return_value=fake_pyproject)
+    mocker_log = mocker.patch("flask.current_app.logger.info")
+
+    runner = CliRunner()
+    runner.invoke(version, [])
+
+    mocker_log.assert_called_once_with(fake_version)

tests/unit/cli/test_token.py

@@ -1,6 +1,8 @@
 import typing as t
 
-from server.cli.token import issue, refresh
+from server.cli.token import check, issue, refresh, whoami
+from server.entities.user_detail import UserDetail
+from server.messages import E, I
 
 
 if t.TYPE_CHECKING:
@@ -28,3 +30,33 @@ def test_token_refresh_calls_refresh_access_token(app: Flask, mocker: MockerFixt
     refresh.main(args=[], standalone_mode=False)
 
     refresh_mock.assert_called_once()
+
+
+def test_token_check_invalid(app, mocker):
+    mocker.patch("server.cli.token.get_access_token", return_value="dummy_token")
+    mocker.patch("server.cli.token.check_token_validity", return_value=False)
+    logger_mock = mocker.patch("server.cli.token.current_app.logger.info")
+
+    check.main(args=[], standalone_mode=False)
+    logger_mock.assert_called_once_with(E.ACCESS_TOKEN_NOT_AVAILABLE)
+
+
+def test_token_check_valid(app, mocker):
+    mocker.patch("server.cli.token.get_access_token", return_value="dummy_token")
+    mocker.patch("server.cli.token.check_token_validity", return_value=True)
+    logger_mock = mocker.patch("server.cli.token.current_app.logger.info")
+
+    check.main(args=[], standalone_mode=False)
+    logger_mock.assert_called_once_with(I.ACCESS_TOKEN_AVAILABLE)
+
+
+def test_token_whoami_logs_owner_userdetail(app, mocker):
+    dummy_owner = UserDetail(id="dummy", user_name="dummy", emails=[], eppns=[])
+    mocker.patch("server.cli.token.get_token_owner", return_value=dummy_owner)
+    logger_mock = mocker.patch("server.cli.token.current_app.logger.info")
+
+    whoami.main(args=[], standalone_mode=False)
+    logger_mock.assert_called_once_with(
+        I.SUCCESS_GET_TOKEN_OWNER,
+        {"user": dummy_owner.model_dump_json(indent=2, ensure_ascii=False)},
+    )

tests/unit/clients/test_services.py

@@ -889,39 +889,6 @@ def test_patch_by_id_with_exclude(app: Flask, mocker: MockerFixture, service_dat
     assert called_kwargs["json"]["request"] == expected_request
 
 
-def test_patch_by_id_with_exclude_param(app, mocker: MockerFixture, service_data):
-    json_data, _ = service_data
-    service_id = json_data["id"]
-    exclude = {"meta", "serviceName"}
-    time_stamp = str(int(time.time()))
-    signature = hashlib.sha256(b"hash").hexdigest()
-    operations = [ReplaceOperation(op="replace", path="serviceName", value="NewName")]
-    response_data = {
-        "schemas": json_data["schemas"],
-        "id": json_data["id"],
-        "serviceName": json_data["serviceName"],
-    }
-    mocker.patch("server.clients.services.get_time_stamp", return_value=time_stamp)
-    mocker.patch("server.clients.services.compute_signature", return_value=signature)
-    mock_patch = mocker.patch("server.clients.services.requests.patch")
-    mock_patch.return_value.text = json.dumps(response_data)
-    mock_patch.return_value.status_code = 200
-    mocker.patch.object(services, "alias_generator", side_effect=lambda x: x)
-    mocker.patch("server.clients.services.repository_updated")
-    original_func = inspect.unwrap(services.patch_by_id)
-    result = original_func(
-        service_id,
-        operations,
-        exclude=exclude,
-        access_token="token",
-        client_secret="secret",
-    )
-    _, called_kwargs = mock_patch.call_args
-    assert "excluded_attributes" in called_kwargs["params"]
-    assert set(called_kwargs["params"]["excluded_attributes"].split(",")) == exclude
-    assert isinstance(result, MapService)
-
-
 def test_patch_by_id_not_found(app: Flask, mocker: MockerFixture) -> None:
     error_data = load_json_data("data/map_error.json")
     operations: list[ReplaceOperation] = [ReplaceOperation(op="replace", path="serviceName", value="NewName")]
@@ -950,18 +917,19 @@ def test_patch_by_id_http_error(app: Flask, mocker: MockerFixture, service_data)
         services.patch_by_id(service_id, operations, access_token="token", client_secret="secret")
 
 
-def test_patch_by_id_bad_request(app, mocker: MockerFixture):
+def test_delete_by_id_success(app: Flask, mocker: MockerFixture) -> None:
 
-    service_id = "dummy_id"
-    operations = [ReplaceOperation(op="replace", path="serviceName", value="NewName")]
-    error_data = load_json_data("data/map_error.json")
-    mock_patch = mocker.patch("server.clients.services.requests.patch")
-    mock_patch.return_value.text = json.dumps(error_data)
-    mock_patch.return_value.status_code = HTTPStatus.BAD_REQUEST
-    original_func = inspect.unwrap(services.patch_by_id)
-    result = original_func(service_id, operations, access_token="token", client_secret="secret")
-    assert isinstance(result, MapError)
-    assert "Not Found" in result.detail
+    service_id = "s1"
+    access_token = "token"
+    client_secret = "secret"
+    mock_delete = mocker.patch("server.clients.services.requests.delete")
+    mock_delete.return_value.text = ""
+    mock_delete.return_value.status_code = 200
+    mocker.patch("server.clients.services.repository_deleted.send")
+    mocker.patch("server.clients.services.repository_updated")
+    result = services.delete_by_id(service_id, access_token=access_token, client_secret=client_secret)
+    mock_delete.assert_called_once()
+    assert result is None
 
 
 def test_delete_by_id_error_response(app: Flask, mocker: MockerFixture) -> None:
@@ -981,21 +949,6 @@ def test_delete_by_id_error_response(app: Flask, mocker: MockerFixture) -> None:
     assert "Not Found" in result.detail
 
 
-def test_delete_by_id_success(app: Flask, mocker: MockerFixture) -> None:
-
-    service_id = "s1"
-    access_token = "token"
-    client_secret = "secret"
-    mock_delete = mocker.patch("server.clients.services.requests.delete")
-    mock_delete.return_value.text = ""
-    mock_delete.return_value.status_code = 200
-    mocker.patch("server.clients.services.repository_deleted.send")
-    mocker.patch("server.clients.services.repository_updated")
-    result = services.delete_by_id(service_id, access_token=access_token, client_secret=client_secret)
-    mock_delete.assert_called_once()
-    assert result is None
-
-
 def test_delete_by_id_http_error(app: Flask, mocker: MockerFixture) -> None:
     service_id = "s1"
     access_token = "token"
@@ -1043,6 +996,13 @@ def test_handle_repository_updated_clears_cache(mocker):
     mock_clear.assert_called_once_with(service.id)
 
 
+def test_handle_repository_updated_no_service_id(mocker):
+    """Covers branch where service or service.id is falsy."""
+    mock_clear = mocker.patch("server.clients.services.get_by_id.clear_cache")
+    handle_repository_updated(_sender=None, service=None)
+    mock_clear.assert_not_called()
+
+
 def test_handle_repository_updated_by_id_clears_cache(mocker):
     """Covers get_by_id.clear_cache(service_id) branch for handle_repository_updated_by_id."""
     mock_clear = mocker.patch("server.clients.services.get_by_id.clear_cache")
@@ -1051,13 +1011,6 @@ def test_handle_repository_updated_by_id_clears_cache(mocker):
     mock_clear.assert_called_once_with(service_id)
 
 
-def test_handle_repository_updated_no_service_id(mocker):
-    """Covers branch where service or service.id is falsy."""
-    mock_clear = mocker.patch("server.clients.services.get_by_id.clear_cache")
-    handle_repository_updated(_sender=None, service=None)
-    mock_clear.assert_not_called()
-
-
 def test_handle_repository_updated_by_id_no_service_id(mocker):
     """Covers branch where service_id is falsy."""
     mock_clear = mocker.patch("server.clients.services.get_by_id.clear_cache")