desdeo 2.0.0__py3-none-any.whl → 2.1.1__py3-none-any.whl

desdeo/api/tests/test_routes.py

@@ -1,48 +1,60 @@
 """Tests related to routes and routers."""
 
+import json
+import time
+
 from fastapi import status
 from fastapi.testclient import TestClient
 
 from desdeo.api.models import (
     CreateSessionRequest,
-    GetSessionRequest,
+    EMOFetchRequest,
+    EMOIterateRequest,
+    EMOIterateResponse,
+    ForestProblemMetaData,
+    GDMSCOREBandsHistoryResponse,
+    GDMScoreBandsInitializationRequest,
+    GDMScoreBandsVoteRequest,
+    GenericIntermediateSolutionResponse,
+    GroupCreateRequest,
+    GroupInfoRequest,
+    GroupModifyRequest,
+    GroupPublic,
     InteractiveSessionDB,
+    IntermediateSolutionRequest,
+    NIMBUSClassificationRequest,
+    NIMBUSClassificationResponse,
+    NIMBUSDeleteSaveRequest,
+    NIMBUSDeleteSaveResponse,
+    NIMBUSFinalizeRequest,
+    NIMBUSFinalizeResponse,
+    NIMBUSInitializationRequest,
+    NIMBUSIntermediateSolutionResponse,
+    NIMBUSSaveRequest,
+    NIMBUSSaveResponse,
+    ProblemDB,
     ProblemGetRequest,
     ProblemInfo,
+    ProblemSelectSolverRequest,
     ReferencePoint,
     RPMSolveRequest,
+    SolutionInfo,
+    SolverSelectionMetadata,
     User,
+    UserPublic,
 )
+from desdeo.api.models.nimbus import NIMBUSInitializationResponse
 from desdeo.api.routers.user_authentication import create_access_token
-from desdeo.problem.testproblems import simple_knapsack_vectors
-
-
-def login(client: TestClient, username="analyst", password="analyst") -> str:  # noqa: S107
-    """Login, returns the access token."""
-    response_login = client.post(
-        "/login",
-        data={"username": username, "password": password, "grant_type": "password"},
-        headers={"content-type": "application/x-www-form-urlencoded"},
-    ).json()
+from desdeo.emo.options.algorithms import rvea_options
+from desdeo.emo.options.templates import ReferencePointOptions
+from desdeo.gdm.score_bands import SCOREBandsGDMConfig
+from desdeo.problem import Problem
+from desdeo.problem.testproblems import dtlz2, simple_knapsack_vectors
+from desdeo.tools.score_bands import KMeansOptions, SCOREBandsConfig
+from desdeo.tools.utils import available_solvers
 
-    return response_login["access_token"]
-
-
-def post_json(client: TestClient, endpoint: str, json: dict, access_token: str):
-    """Makes a post request and returns the response."""
-    return client.post(
-        endpoint,
-        json=json,
-        headers={"Authorization": f"Bearer {access_token}", "Content-Type": "application/json"},
-    )
-
-
-def get_json(client: TestClient, endpoint: str, access_token: str):
-    """Makes a get request and returns the response."""
-    return client.get(
-        endpoint,
-        headers={"Authorization": f"Bearer {access_token}", "Content-Type": "application/json"},
-    )
+from .conftest import get_json, login, post_file_multipart, post_json
+from .test_models import compare_models
 
 
 def test_user_login(client: TestClient):
@@ -114,6 +126,7 @@ def test_get_problem(client: TestClient):
 
     assert info.id == 1
     assert info.name == "dtlz2"
+    assert info.problem_metadata is None
 
     response = post_json(client, "problem/get", ProblemGetRequest(problem_id=2).model_dump(), access_token)
 
@@ -123,6 +136,7 @@ def test_get_problem(client: TestClient):
 
     assert info.id == 2
     assert info.name == "The river pollution problem"
+    assert isinstance(info.problem_metadata.forest_metadata[0], ForestProblemMetaData)
 
 
 def test_add_problem(client: TestClient):
@@ -145,7 +159,25 @@ def test_add_problem(client: TestClient):
 
     problems = response.json()
 
-    assert len(problems) == 3
+    assert len(problems) == 4
+
+
+def test_add_problem_json(client: TestClient, session_and_user: dict):
+    """Test that adding a problem to the database works with JSON files."""
+    session = session_and_user["session"]
+    access_token = login(client)
+    problem = dtlz2(5, 3)
+
+    payload = problem.model_dump()
+    raw = json.dumps(payload).encode("utf-8")
+
+    response = post_file_multipart(client, "/problem/add_json", raw, access_token)
+
+    assert response.status_code == 200
+
+    problem_from_db = session.get(ProblemDB, 4)
+
+    assert compare_models(problem, Problem.from_problemdb(problem_from_db))
 
 
 def test_new_session(client: TestClient, session_and_user: dict):
@@ -170,37 +202,110 @@ def test_new_session(client: TestClient, session_and_user: dict):
 
 
 def test_get_session(client: TestClient, session_and_user: dict):
-    """Test that getting a session works as intended."""
+    """Test that getting a session via GET works as intended."""
     user: User = session_and_user["user"]
 
     access_token = login(client)
 
     # no sessions
-    request = GetSessionRequest(session_id=1)
-    response = post_json(client, "/session/get", request.model_dump(), access_token)
+    response = client.get(
+        "/session/get/1",
+        headers={"Authorization": f"Bearer {access_token}"},
+    )
     assert response.status_code == status.HTTP_404_NOT_FOUND
 
-    # add some sessions
-    request = CreateSessionRequest(info="My session")
+    # add session 1
+    request = CreateSessionRequest(info="Session 1")
     response = post_json(client, "/session/new", request.model_dump(), access_token)
     assert response.status_code == status.HTTP_200_OK
-
     assert user.active_session_id == 1
 
-    request = CreateSessionRequest(info="My session")
+    # add session 2
+    request = CreateSessionRequest(info="Session 2")
     response = post_json(client, "/session/new", request.model_dump(), access_token)
     assert response.status_code == status.HTTP_200_OK
-
     assert user.active_session_id == 2
 
-    # sessions with id 1 and 2 should exist
-    request = GetSessionRequest(session_id=1)
-    response = post_json(client, "/session/get", request.model_dump(), access_token)
+    # fetch session 1
+    response = client.get(
+        "/session/get/1",
+        headers={"Authorization": f"Bearer {access_token}"},
+    )
     assert response.status_code == status.HTTP_200_OK
+    assert response.json()["id"] == 1
 
-    request = GetSessionRequest(session_id=2)
-    response = post_json(client, "/session/get", request.model_dump(), access_token)
+    # fetch session 2
+    response = client.get(
+        "/session/get/2",
+        headers={"Authorization": f"Bearer {access_token}"},
+    )
     assert response.status_code == status.HTTP_200_OK
+    assert response.json()["id"] == 2
+
+
+def test_get_all_sessions_success(client: TestClient, session_and_user: dict):
+    """Test getting all sessions when sessions exist."""
+    access_token = login(client)
+
+    # create 2 test sessions
+    post_json(client, "/session/new", {"info": "S1"}, access_token)
+    post_json(client, "/session/new", {"info": "S2"}, access_token)
+
+    response = client.get(
+        "/session/get_all",
+        headers={"Authorization": f"Bearer {access_token}"},
+    )
+
+    assert response.status_code == status.HTTP_200_OK
+    data = response.json()
+    assert isinstance(data, list)
+    assert len(data) == 2
+
+
+def test_get_all_sessions_not_found(client: TestClient, session_and_user: dict):
+    """Test get_all returns 404 if user has no sessions."""
+    access_token = login(client)
+
+    response = client.get(
+        "/session/get_all",
+        headers={"Authorization": f"Bearer {access_token}"},
+    )
+
+    assert response.status_code == status.HTTP_404_NOT_FOUND
+
+
+def test_delete_session_success(client: TestClient, session_and_user: dict):
+    """Test deleting an existing session."""
+    access_token = login(client)
+
+    # create session
+    post_json(client, "/session/new", {"info": "To delete"}, access_token)
+
+    response = client.delete(
+        "/session/1",
+        headers={"Authorization": f"Bearer {access_token}"},
+    )
+
+    assert response.status_code == status.HTTP_204_NO_CONTENT
+
+    # verify it's gone
+    response = client.get(
+        "/session/get/1",
+        headers={"Authorization": f"Bearer {access_token}"},
+    )
+    assert response.status_code == status.HTTP_404_NOT_FOUND
+
+
+def test_delete_session_not_found(client: TestClient, session_and_user: dict):
+    """Test deleting a non-existent session returns 404."""
+    access_token = login(client)
+
+    response = client.delete(
+        "/session/999",
+        headers={"Authorization": f"Bearer {access_token}"},
+    )
+
+    assert response.status_code == status.HTTP_404_NOT_FOUND
 
 
 def test_rpm_solve(client: TestClient):
@@ -214,3 +319,757 @@ def test_rpm_solve(client: TestClient):
     response = post_json(client, "/method/rpm/solve", request.model_dump(), access_token)
 
     assert response.status_code == status.HTTP_200_OK
+
+
+def test_nimbus_solve(client: TestClient):
+    """Test that using the NIMBUS method works as expected."""
+    access_token = login(client)
+
+    preference = ReferencePoint(aspiration_levels={"f_1": 0.5, "f_2": 0.6, "f_3": 0.4})
+
+    request = NIMBUSClassificationRequest(
+        problem_id=1, preference=preference, current_objectives={"f_1": 0.6, "f_2": 0.4, "f_3": 0.5}, num_desired=3
+    )
+
+    response = post_json(client, "/method/nimbus/solve", request.model_dump(), access_token)
+    assert response.status_code == status.HTTP_200_OK
+    result: NIMBUSClassificationResponse = NIMBUSClassificationResponse.model_validate(
+        json.loads(response.content.decode("utf-8"))
+    )
+    assert result.previous_preference == preference
+    assert len(result.all_solutions) == 3
+
+    request = NIMBUSSaveRequest(
+        problem_id=1,
+        parent_state_id=result.state_id,
+        solution_info=[
+            SolutionInfo(state_id=1, solution_index=0, name="Test solution 1"),
+            SolutionInfo(state_id=1, solution_index=2, name="Test solution 3"),
+            SolutionInfo(state_id=1, solution_index=2, name="Test solution 34"),  # saved twice!
+        ],
+    )
+
+    response = post_json(client, "/method/nimbus/save", request.model_dump(), access_token)
+    assert response.status_code == status.HTTP_200_OK
+    result2: NIMBUSSaveResponse = NIMBUSSaveResponse.model_validate(json.loads(response.content.decode("utf-8")))
+    assert result2.state_id is not None
+
+    preference = ReferencePoint(aspiration_levels={"f_1": 0.1, "f_2": 0.1, "f_3": 0.9})
+
+    request = NIMBUSClassificationRequest(
+        problem_id=1,
+        preference=preference,
+        current_objectives=result.current_solutions[0].objective_values,
+        num_desired=3,
+        parent_state_id=result2.state_id,
+    )
+
+    response = post_json(client, "/method/nimbus/solve", request.model_dump(), access_token)
+
+    assert response.status_code == status.HTTP_200_OK
+    result: NIMBUSClassificationResponse = NIMBUSClassificationResponse.model_validate(
+        json.loads(response.content.decode("utf-8"))
+    )
+    assert result.previous_preference == preference
+    # We saved the same solution twice, so the filtering should remove one of those.
+    assert len(result.saved_solutions) == 2
+    assert len(result.all_solutions) == 6  # should not count saved solutions twice
+
+    # Save some more solutions!
+    request = NIMBUSSaveRequest(
+        problem_id=1,
+        parent_state_id=result.state_id,
+        solution_info=[SolutionInfo(state_id=result.state_id, solution_index=1, name="Test solution 2")],
+    )
+
+    response = post_json(client, "/method/nimbus/save", request.model_dump(), access_token)
+    assert response.status_code == status.HTTP_200_OK
+    result2: NIMBUSSaveResponse = NIMBUSSaveResponse.model_validate(json.loads(response.content.decode("utf-8")))
+    assert result2.state_id is not None
+
+    # Same as the first one. Therefore, (I believe) STOM and ASF give same solutions,
+    # which should be reflected on the amount of all solutions
+    preference = ReferencePoint(aspiration_levels={"f_1": 0.5, "f_2": 0.6, "f_3": 0.4})
+
+    request = NIMBUSClassificationRequest(
+        problem_id=1,
+        preference=preference,
+        current_objectives=result.current_solutions[0].objective_values,
+        num_desired=3,
+        parent_state_id=result2.state_id,
+    )
+
+    response = post_json(client, "/method/nimbus/solve", request.model_dump(), access_token)
+    assert response.status_code == status.HTTP_200_OK
+    result3: NIMBUSClassificationResponse = NIMBUSClassificationResponse.model_validate(
+        json.loads(response.content.decode("utf-8"))
+    )
+    assert result3.previous_preference == preference
+    assert len(result3.saved_solutions) == 3
+    assert len(result3.all_solutions) == 7
+
+
+def test_intermediate_solve(client: TestClient):
+    """Test that solving intermediate solutions works as expected."""
+    access_token = login(client)
+
+    preference = ReferencePoint(aspiration_levels={"f_1": 0.5, "f_2": 0.6, "f_3": 0.4})
+
+    request = NIMBUSClassificationRequest(
+        problem_id=1, preference=preference, current_objectives={"f_1": 0.6, "f_2": 0.4, "f_3": 0.5}, num_desired=2
+    )
+
+    response = post_json(client, "/method/nimbus/solve", request.model_dump(), access_token)
+    assert response.status_code == status.HTTP_200_OK
+    result: NIMBUSClassificationResponse = NIMBUSClassificationResponse.model_validate(
+        json.loads(response.content.decode("utf-8"))
+    )
+    assert len(result.all_solutions) == 2
+
+    # Save some solutions!
+    solution_1 = SolutionInfo(state_id=result.state_id, solution_index=0)
+    solution_2 = SolutionInfo(state_id=result.state_id, solution_index=1, name="named solution")
+
+    # Create request for intermediate solutions using solutions created with nimbus solve
+    request = IntermediateSolutionRequest(
+        problem_id=1,
+        context="test",
+        reference_solution_1=solution_1,
+        reference_solution_2=solution_2,
+        num_desired=3,
+    )
+
+    # Test the generic intermediate endpoint
+    response = post_json(client, "/method/generic/intermediate", request.model_dump(), access_token)
+    assert response.status_code == status.HTTP_200_OK
+    result: GenericIntermediateSolutionResponse = GenericIntermediateSolutionResponse.model_validate(
+        json.loads(response.content.decode("utf-8"))
+    )
+
+    # Test the NIMBUS-specific intermediate endpoint
+    nimbus_request = IntermediateSolutionRequest(
+        problem_id=1,
+        context="nimbus",
+        reference_solution_1=solution_1,
+        reference_solution_2=solution_2,
+        num_desired=2,
+    )
+
+    nimbus_response = post_json(client, "/method/nimbus/intermediate", nimbus_request.model_dump(), access_token)
+    assert nimbus_response.status_code == status.HTTP_200_OK
+    nimbus_result = NIMBUSIntermediateSolutionResponse.model_validate(
+        json.loads(nimbus_response.content.decode("utf-8"))
+    )
+
+    # Verify the NIMBUS response contains expected fields
+    assert nimbus_result.state_id is not None
+    assert len(nimbus_result.current_solutions) == 2
+    assert len(nimbus_result.all_solutions) == 7
+
+
+def test_nimbus_initialize(client: TestClient):
+    """Test that initializing NIMBUS works without specifying a solver."""
+    access_token = login(client)
+
+    # test with no starting point
+    request = NIMBUSInitializationRequest(problem_id=1, solver=None)
+
+    response = post_json(client, "/method/nimbus/initialize", request.model_dump(), access_token)
+
+    assert response.status_code == status.HTTP_200_OK
+    init_result = NIMBUSInitializationResponse.model_validate(json.loads(response.content))
+
+    assert init_result.state_id == 1
+    assert len(init_result.current_solutions) == 1
+    assert len(init_result.saved_solutions) == 0
+    assert len(init_result.all_solutions) == 1
+
+    # test with starting point given as solution info
+    request_w_info = NIMBUSInitializationRequest(
+        problem_id=1, starting_point=SolutionInfo(state_id=1, solution_index=0)
+    )
+
+    response_w_info = post_json(client, "/method/nimbus/initialize", request_w_info.model_dump(), access_token)
+
+    assert response_w_info.status_code == status.HTTP_200_OK
+    result_w_info = NIMBUSInitializationResponse.model_validate(json.loads(response_w_info.content))
+
+    assert result_w_info.state_id == 2
+    assert len(result_w_info.current_solutions) == 1
+    assert len(result_w_info.saved_solutions) == 0
+    assert len(result_w_info.all_solutions) == 1  # this is still one because the new solution will be a duplicate.
+
+    # test with starting point given as a reference point
+    request_w_ref = NIMBUSInitializationRequest(
+        problem_id=1, starting_point=ReferencePoint(aspiration_levels={"f_1": 0.2, "f_2": 0.8, "f_3": 0.4})
+    )
+
+    response_w_ref = post_json(client, "/method/nimbus/initialize", request_w_ref.model_dump(), access_token)
+
+    assert response_w_ref.status_code == status.HTTP_200_OK
+    result_w_ref = NIMBUSInitializationResponse.model_validate(json.loads(response_w_ref.content))
+
+    assert result_w_ref.state_id == 3
+    assert len(result_w_ref.current_solutions) == 1
+    assert len(result_w_ref.saved_solutions) == 0
+    assert len(result_w_ref.all_solutions) == 2  # we should have a new one
+
+
+def test_nimbus_finalize(client: TestClient):
+    """Test for seeing if NIMBUS finalization works."""
+    access_token = login(client)
+
+    # create some previous iterations
+    request = NIMBUSInitializationRequest(problem_id=1)
+    response = post_json(client, "/method/nimbus/get-or-initialize", request.model_dump(), access_token)
+    assert response.status_code == status.HTTP_200_OK
+    init_response = NIMBUSInitializationResponse.model_validate(json.loads(response.content))
+    assert init_response.state_id == 1
+    assert len(init_response.current_solutions) == 1
+    assert len(init_response.saved_solutions) == 0
+    assert len(init_response.all_solutions) == 1
+
+    preference = ReferencePoint(aspiration_levels={"f_1": 0.5, "f_2": 0.6, "f_3": 0.4})
+
+    request = NIMBUSClassificationRequest(
+        problem_id=1, preference=preference, current_objectives={"f_1": 0.6, "f_2": 0.4, "f_3": 0.5}, num_desired=3
+    )
+
+    response = post_json(client, "/method/nimbus/solve", request.model_dump(), access_token)
+    assert response.status_code == status.HTTP_200_OK
+    result: NIMBUSClassificationResponse = NIMBUSClassificationResponse.model_validate(
+        json.loads(response.content.decode("utf-8"))
+    )
+    assert result.previous_preference == preference
+    assert len(result.current_solutions) == 3
+
+    solution_index = 2
+
+    optim_obj = result.current_solutions[solution_index].objective_values
+    optim_var = result.current_solutions[solution_index].variable_values
+
+    state_id = result.state_id
+
+    request = NIMBUSInitializationRequest(problem_id=1)
+    response = post_json(client, "/method/nimbus/get-or-initialize", request.model_dump(), access_token)
+    assert response.status_code == status.HTTP_200_OK
+    classify_result = NIMBUSClassificationResponse.model_validate(json.loads(response.content))
+    assert classify_result.state_id == 2
+    assert len(classify_result.current_solutions) == 3
+    assert len(classify_result.saved_solutions) == 0
+    assert len(classify_result.all_solutions) == 4
+
+    request = NIMBUSFinalizeRequest(
+        problem_id=1,
+        solution_info=SolutionInfo(state_id=state_id, solution_index=solution_index),
+    )
+
+    # Finalize the process
+    response = post_json(client, "/method/nimbus/finalize", request.model_dump(), access_token)
+    assert response.status_code == status.HTTP_200_OK
+    result: NIMBUSFinalizeResponse = NIMBUSFinalizeResponse.model_validate(json.loads(response.content.decode("utf-8")))
+    assert result.response_type == "nimbus.finalize"
+    assert result.final_solution.objective_values == optim_obj
+    assert result.final_solution.variable_values == optim_var
+    assert result.final_solution.state_id != result.state_id
+    assert result.all_solutions is not None
+
+    request = NIMBUSInitializationRequest(problem_id=1)
+
+    # The last item in the pipe is a finalize state, so we should be getting a finalize response.
+    response = post_json(client, "/method/nimbus/get-or-initialize", request.model_dump(), access_token)
+    assert response.status_code == status.HTTP_200_OK
+    result: NIMBUSFinalizeResponse = NIMBUSFinalizeResponse.model_validate(json.loads(response.content.decode("utf-8")))
+    assert result.response_type == "nimbus.finalize"
+    assert result.final_solution.objective_values == optim_obj
+    assert result.final_solution.variable_values == optim_var
+    assert result.final_solution.state_id != result.state_id
+    assert result.all_solutions is not None
+
+
+def test_nimbus_save_and_delete_save(client: TestClient):
+    """Test that NIMBUS saving and save deletion works."""
+    access_token = login(client)
+
+    # 1. Initialize
+    request: NIMBUSInitializationRequest = NIMBUSInitializationRequest(problem_id=1)
+    response = post_json(client, "/method/nimbus/initialize", request.model_dump(), access_token)
+    init_result: NIMBUSInitializationResponse = NIMBUSInitializationResponse.model_validate(
+        json.loads(response.content)
+    )
+    assert init_result.state_id == 1
+
+    # 2. Iterate
+    request: NIMBUSClassificationRequest = NIMBUSClassificationRequest(
+        problem_id=1,
+        preference=ReferencePoint(
+            aspiration_levels={
+                "f_1": 0.1,
+                "f_2": 0.8,
+                "f_3": 0.5,
+            }
+        ),
+        current_objectives=init_result.current_solutions[0].objective_values,
+        parent_state_id=1,
+        num_desired=3,
+    )
+    response = post_json(client, "/method/nimbus/solve", request.model_dump(), access_token)
+    solve_result: NIMBUSClassificationResponse = NIMBUSClassificationResponse.model_validate(
+        json.loads(response.content)
+    )
+    assert solve_result.state_id == 2
+
+    # 3. Save
+    request: NIMBUSSaveRequest = NIMBUSSaveRequest(
+        problem_id=1, parent_state_id=2, solution_info=[SolutionInfo(state_id=2, solution_index=1)]
+    )
+    response = post_json(client, "/method/nimbus/save", request.model_dump(), access_token)
+    save_result: NIMBUSSaveResponse = NIMBUSSaveResponse.model_validate(json.loads(response.content))
+    assert save_result.state_id == 3
+
+    # Assert that stuff is saved
+    request: NIMBUSClassificationRequest = NIMBUSClassificationRequest(
+        problem_id=1,
+        preference=ReferencePoint(
+            aspiration_levels={
+                "f_1": 0.9,
+                "f_2": 0.1,
+                "f_3": 0.5,
+            }
+        ),
+        current_objectives=solve_result.current_solutions[0].objective_values,
+        num_desired=1,
+        parent_state_id=3,
+    )
+    response = post_json(client, "/method/nimbus/solve", request.model_dump(), access_token)
+    solve_result: NIMBUSClassificationResponse = NIMBUSClassificationResponse.model_validate(
+        json.loads(response.content)
+    )
+    assert solve_result.state_id == 4
+    assert len(solve_result.saved_solutions) > 0
+
+    # 4. Delete save
+    request: NIMBUSDeleteSaveRequest = NIMBUSDeleteSaveRequest(state_id=2, solution_index=1)
+    response = post_json(client, "/method/nimbus/delete_save", request.model_dump(), access_token)
+    delete_save_result: NIMBUSDeleteSaveResponse = NIMBUSDeleteSaveResponse.model_validate(json.loads(response.content))
+
+    assert delete_save_result
+
+    # Assert that saved stuff has been deleted
+
+    # Assert that stuff is saved
+    request: NIMBUSClassificationRequest = NIMBUSClassificationRequest(
+        problem_id=1,
+        preference=ReferencePoint(
+            aspiration_levels={
+                "f_1": 0.1,
+                "f_2": 0.9,
+                "f_3": 0.4,
+            }
+        ),
+        current_objectives=solve_result.current_solutions[0].objective_values,
+        num_desired=1,
+        parent_state_id=4,
+    )
+    response = post_json(client, "/method/nimbus/solve", request.model_dump(), access_token)
+    solve_result: NIMBUSClassificationResponse = NIMBUSClassificationResponse.model_validate(
+        json.loads(response.content)
+    )
+    assert solve_result.state_id == 5
+    assert len(solve_result.saved_solutions) == 0
+
+
+def test_add_new_dm(client: TestClient):
+    """Test that adding a decision maker works."""
+    # Create a new user to the database
+    good_response = client.post(
+        "/add_new_dm",
+        data={"username": "new_dm", "password": "new_dm", "grant_type": "password"},
+        headers={"content-type": "application/x-www-form-urlencoded"},
+    )
+    assert good_response.status_code == status.HTTP_201_CREATED
+
+    # There already should be a user named new_dm, so we shouldn't create another one.
+    bad_response = client.post(
+        "/add_new_dm",
+        data={"username": "new_dm", "password": "new_dm", "grant_type": "password"},
+        headers={"content-type": "application/x-www-form-urlencoded"},
+    )
+    assert bad_response.status_code == status.HTTP_409_CONFLICT
+
+
+def test_add_new_analyst(client: TestClient):
+    """Test that adding a new analyst works."""
+    # Try to create an analyst without logging in
+    nologin_response = client.post(
+        "/add_new_analyst",
+        data={"username": "new_analyst", "password": "new_analyst", "grant_type": "password"},
+        headers={"content-type": "application/x-www-form-urlencoded"},
+    )
+
+    # No user
+    assert nologin_response.status_code == status.HTTP_401_UNAUTHORIZED
+
+    # Try to create an analyst using a dm account.
+    response = client.post(
+        "/add_new_dm",
+        data={"username": "new_dm", "password": "new_dm", "grant_type": "password"},
+        headers={"content-type": "application/x-www-form-urlencoded"},
+    )
+    assert response.status_code == status.HTTP_201_CREATED
+
+    dm_access_token = login(client, username="new_dm", password="new_dm")  # noqa: S106
+
+    dm_response = client.post(
+        "/add_new_analyst",
+        data={"username": "new_analyst", "password": "new_analyst", "grant_type": "password"},
+        headers={"Authorization": f"Bearer {dm_access_token}", "content-type": "application/x-www-form-urlencoded"},
+    )
+
+    # Creating an analyst using unauthorized user should return 401 status
+    assert dm_response.status_code == status.HTTP_401_UNAUTHORIZED
+
+    # Login with proper user
+    analyst_access_token = login(client)
+
+    good_response = client.post(
+        "/add_new_analyst",
+        data={"username": "new_analyst", "password": "new_analyst", "grant_type": "password"},
+        headers={
+            "Authorization": f"Bearer {analyst_access_token}",
+            "content-type": "application/x-www-form-urlencoded",
+        },
+    )
+
+    # Creating a new analyst with an analyst user should return 201
+    assert good_response.status_code == status.HTTP_201_CREATED
+
+    bad_response = client.post(
+        "/add_new_analyst",
+        data={"username": "new_analyst", "password": "new_analyst", "grant_type": "password"},
+        headers={
+            "Authorization": f"Bearer {analyst_access_token}",
+            "content-type": "application/x-www-form-urlencoded",
+        },
+    )
+
+    # Trying to create an analyst with username that is already in use should return 409
+    assert bad_response.status_code == status.HTTP_409_CONFLICT
+
+
+def test_login_logout(client: TestClient):
+    """Test that logging out works."""
+    # Login (sets refresh token cookie)
+    login(client=client, username="analyst", password="analyst")  # noqa: S106
+
+    # Refresh access token
+    response = client.post("/refresh")
+    # Access token refreshed
+    assert response.status_code == status.HTTP_200_OK
+
+    # Logout (remove the refresh token cookie)
+    response = client.post(
+        "/logout",
+    )
+    assert response.status_code == status.HTTP_200_OK
+
+    # Refresh access token
+    response = client.post(
+        "/refresh",
+        headers={"content-type": "application/x-www-form-urlencoded"},
+    )
+    # Access token NOT refreshed
+    assert response.status_code == status.HTTP_401_UNAUTHORIZED
+
+
+def test_group_operations(client: TestClient):
+    """Tests for websocket endpoints and websockets."""
+    create_endpoint = "/gdm/create_group"
+    delete_endpoint = "/gdm/delete_group"
+    add_user_endpoint = "/gdm/add_to_group"
+    remove_user_endpoint = "/gdm/remove_from_group"
+    group_info_endpoint = "/gdm/get_group_info"
+
+    # login to analyst
+    access_token = login(client=client, username="analyst", password="analyst")  # noqa: S106
+
+    def get_info(gid: int):
+        return post_json(
+            client=client,
+            endpoint=group_info_endpoint,
+            json=GroupInfoRequest(
+                group_id=gid,
+            ).model_dump(),
+            access_token=access_token,
+        )
+
+    def get_user_info(token: str):
+        return client.get(
+            "/user_info",
+            headers={
+                "Authorization": f"Bearer {token}",
+                "content-type": "application/x-www-form-urlencoded",
+            },
+        )
+
+    # try to create group with no problem
+    response = post_json(
+        client=client,
+        endpoint=create_endpoint,
+        json=GroupCreateRequest(group_name="testGroup", problem_id=10).model_dump(),
+        access_token=access_token,
+    )
+    assert response.status_code == 404
+
+    # Create group properly
+    response = post_json(
+        client=client,
+        endpoint=create_endpoint,
+        json=GroupCreateRequest(group_name="testGroup", problem_id=2).model_dump(),
+        access_token=access_token,
+    )
+    assert response.status_code == 201
+
+    # Add a user to database
+    response = client.post(
+        "/add_new_dm",
+        data={"username": "new_dm", "password": "new_dm", "grant_type": "password"},
+        headers={"content-type": "application/x-www-form-urlencoded"},
+    )
+    assert response.status_code == status.HTTP_201_CREATED
+
+    # Add user to a group
+    response = post_json(
+        client=client,
+        endpoint=add_user_endpoint,
+        json=GroupModifyRequest(group_id=1, user_id=2).model_dump(),
+        access_token=access_token,
+    )
+    assert response.status_code == status.HTTP_200_OK
+    response = get_info(1)
+    assert response.status_code == status.HTTP_200_OK
+    group: GroupPublic = GroupPublic.model_validate(json.loads(response.content.decode("utf-8")))
+    assert 2 in group.user_ids
+    assert 1 not in group.user_ids
+
+    user_info = get_user_info(access_token)
+    user: UserPublic = UserPublic.model_validate(json.loads(user_info.content.decode("utf-8")))
+    assert 1 in user.group_ids
+
+    dm_access_token = login(client, "new_dm", "new_dm")
+
+    user_info = get_user_info(dm_access_token)
+    dm_user: UserPublic = UserPublic.model_validate(json.loads(user_info.content.decode("utf-8")))
+    assert 1 in dm_user.group_ids
+
+    # TODO: websocket testing and result fetching?
+
+    # Remove user from a group
+    response = post_json(
+        client=client,
+        endpoint=remove_user_endpoint,
+        json=GroupModifyRequest(group_id=1, user_id=2).model_dump(),
+        access_token=access_token,
+    )
+    assert response.status_code == status.HTTP_200_OK
+    response = get_info(1)
+    assert response.status_code == status.HTTP_200_OK
+    group: GroupPublic = GroupPublic.model_validate(json.loads(response.content.decode("utf-8")))
+    assert 2 not in group.user_ids
+
+    user_info = get_user_info(dm_access_token)
+    user: UserPublic = UserPublic.model_validate(json.loads(user_info.content.decode("utf-8")))
+    assert 1 not in user.group_ids
+
+    user_info = get_user_info(access_token)
+    user: UserPublic = UserPublic.model_validate(json.loads(user_info.content.decode("utf-8")))
+    assert 1 in user.group_ids
+
+    # Delete the group
+    response = post_json(
+        client=client,
+        endpoint=delete_endpoint,
+        json=GroupInfoRequest(
+            group_id=1,
+        ).model_dump(),
+        access_token=access_token,
+    )
+    assert response.status_code == status.HTTP_200_OK
+    response = get_info(1)
+    assert response.status_code == status.HTTP_404_NOT_FOUND
+
+    user_info = get_user_info(access_token)
+    user: UserPublic = UserPublic.model_validate(json.loads(user_info.content.decode("utf-8")))
+    assert 1 not in user.group_ids
+
+
+def test_preferred_solver(client: TestClient):
+    """Test that setting a preferred solver for the problem is ok."""
+    access_token = login(client)
+
+    request = ProblemSelectSolverRequest(problem_id=1, solver_string_representation="THIS SOLVER DOESN'T EXIST")
+    response = post_json(client, "/problem/assign_solver", request.model_dump(), access_token)
+    assert response.status_code == 404
+
+    request = ProblemSelectSolverRequest(problem_id=1, solver_string_representation="pyomo_cbc")
+    response = post_json(client, "/problem/assign_solver", request.model_dump(), access_token)
+    assert response.status_code == 200
+
+    request = {"problem_id": 1, "metadata_type": "solver_selection_metadata"}
+    response = post_json(client, "/problem/get_metadata", request, access_token)
+    assert response.status_code == 200
+
+    model = SolverSelectionMetadata.model_validate(response.json()[0])
+
+    assert model.metadata_type == "solver_selection_metadata"
+    assert model.solver_string_representation == "pyomo_cbc"
+
+    # Test that the solver is in use
+    try:
+        request = NIMBUSInitializationRequest(problem_id=1)
+        response = post_json(client, "/method/nimbus/initialize", request.model_dump(), access_token)
+        model = NIMBUSInitializationResponse.model_validate(response.json())
+    except Exception as e:
+        print(e)
+        print("^ This outcome is expected since pyomo_cbc doesn't support nonlinear problems.")
+        print("  As that solver is what we set it to be in the start, we can verify that they actually get used.")
+
+
+def test_get_available_solvers(client: TestClient):
+    """Test that available solvers can be fetched."""
+    response = client.get("/problem/assign/solver")
+
+    assert response.status_code == 200
+
+    data = response.json()
+    assert isinstance(data, list)
+
+    # Check that the returned solver names match the available solvers
+    assert set(data) == set(available_solvers.keys())
+
+
+def test_emo_solve_with_reference_point(client: TestClient):
+    """Test that using EMO with reference point works as expected."""
+    return
+    # TODO: This test fails because of websocket issues. Fix those and re-enable the test.
+    access_token = login(client)
+    request = EMOIterateRequest(
+        problem_id=1,
+        template_options=[rvea_options.template],
+        preference_options=ReferencePointOptions(preference={"f_1": 0.5, "f_2": 0.3, "f_3": 0.4}, method="Hakanen"),
+    )
+
+    response = post_json(client, "/method/emo/iterate", request.model_dump(), access_token)
+
+    assert response.status_code == status.HTTP_200_OK
+
+    # Validate the response structure
+    emo_response = EMOIterateResponse.model_validate(response.json())
+    assert emo_response.client_id is not None
+    state_id = emo_response.state_id
+
+    initial_time = time.time()
+    with client.websocket_connect(f"/method/emo/ws/{emo_response.client_id}") as websocket:
+        while time.time() - initial_time < 10:
+            message = websocket.receive_json()
+            if message.get("message") == f"Finished {emo_response.method_ids[0]}":
+                break
+    # Fetch the state to verify it worked
+    fetch_request = EMOFetchRequest(problem_id=1, parent_state_id=state_id)
+    response = post_json(client, "/method/emo/fetch", fetch_request.model_dump(), access_token)
+
+
+def test_get_problem_metadata(client: TestClient):
+    """Test that fetching problem metadata works."""
+    access_token = login(client=client)
+
+    # Problem with no metadata
+    req = {"problem_id": 1, "metadata_type": "forest_problem_metadata"}
+    response = post_json(client=client, endpoint="/problem/get_metadata", json=req, access_token=access_token)
+    assert response.status_code == 200
+    assert response.json() == []
+
+    # Problem with forest metadata
+    req = {"problem_id": 2, "metadata_type": "forest_problem_metadata"}
+    response = post_json(client=client, endpoint="/problem/get_metadata", json=req, access_token=access_token)
+    assert response.status_code == 200
+    assert response.json()[0]["metadata_type"] == "forest_problem_metadata"
+    assert response.json()[0]["schedule_dict"] == {"type": "dict"}
+
+    # No problem
+    req = {"problem_id": 4, "metadata_type": "forest_problem_metadata"}
+    response = post_json(client=client, endpoint="/problem/get_metadata", json=req, access_token=access_token)
+    assert response.status_code == 404
+
+
+def test_gdm_score_bands(client: TestClient):
+    """Test score bands endpoints."""
+    access_token = login(client=client)
+
+    # create group
+    req = GroupCreateRequest(
+        group_name="group",
+        problem_id=3,  # The discrete representation problem
+    ).model_dump()
+    response = post_json(client=client, endpoint="/gdm/create_group", json=req, access_token=access_token)
+    assert response.status_code == 201
+
+    # Add a dm to the group
+    # Create a new user to the database
+    response = client.post(
+        "/add_new_dm",
+        data={"username": "dm", "password": "dm", "grant_type": "password"},
+        headers={"content-type": "application/x-www-form-urlencoded"},
+    )
+    assert response.status_code == 201
+
+    req = GroupModifyRequest(group_id=1, user_id=2).model_dump()
+    response = post_json(client=client, endpoint="/gdm/add_to_group", json=req, access_token=access_token)
+    assert response.status_code == 200
+
+    access_token = login(client=client, username="dm", password="dm")
+
+    # Now we have a group, so let's get on with making stuff with gdm score bands.
+    req = GDMScoreBandsInitializationRequest(
+        group_id=1,
+        score_bands_config=SCOREBandsGDMConfig(
+            score_bands_config=SCOREBandsConfig(clustering_algorithm=KMeansOptions(n_clusters=5)), from_iteration=None
+        ),
+    ).model_dump()
+    response = post_json(
+        client=client, endpoint="/gdm-score-bands/get-or-initialize", json=req, access_token=access_token
+    )
+    assert response.status_code == 200
+    response_innards = GDMSCOREBandsHistoryResponse.model_validate(response.json())
+    cluster_size_1 = len(response_innards.history[-1].result.clusters)
+
+    # VOTE AND CONFIRM
+    req = GDMScoreBandsVoteRequest(
+        group_id=1,
+        vote=4,
+    ).model_dump()
+    response = post_json(client=client, endpoint="/gdm-score-bands/vote", json=req, access_token=access_token)
+    assert response.status_code == 200
+    req = GroupInfoRequest(group_id=1).model_dump()
+    response = post_json(client=client, endpoint="/gdm-score-bands/confirm", json=req, access_token=access_token)
+    assert response.status_code == 200
+
+    req = GDMScoreBandsInitializationRequest(
+        group_id=1,
+        score_bands_config=SCOREBandsGDMConfig(
+            score_bands_config=SCOREBandsConfig(clustering_algorithm=KMeansOptions(n_clusters=5)),
+            from_iteration=response_innards.history[-1].latest_iteration,
+        ),
+    ).model_dump()
+    response = post_json(
+        client=client, endpoint="/gdm-score-bands/get-or-initialize", json=req, access_token=access_token
+    )
+    assert response.status_code == 200
+    response_innards = GDMSCOREBandsHistoryResponse.model_validate(response.json())
+    cluster_size_2 = len(response_innards.history[-1].result.clusters)
+
+    # Since we've made one iteration, the length of the clustering and therefore the active
+    # indices should be smaller the second time around than the first one.
+    assert cluster_size_1 > cluster_size_2
+
+    # TODO: Test reverting, re-clustering