RolePlay/src/test/java/de/neitzel/roleplay/business/InMemorySessionServiceTest.java

package de.neitzel.roleplay.business;

import de.neitzel.roleplay.fascade.model.CreateSessionRequest;
import de.neitzel.roleplay.fascade.model.SessionResponse;
import de.neitzel.roleplay.fascade.model.TurnRequest;
import de.neitzel.roleplay.fascade.model.TurnResponse;
import de.neitzel.roleplay.fascade.model.UserActionRequest;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import java.util.Optional;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;

/**
 * Unit tests for {@link InMemorySessionService}.
 */
class InMemorySessionServiceTest {

    /**
     * Instance under test – no CDI dependencies to mock.
     */
    private InMemorySessionService sessionService;

    /**
     * Creates a fresh service instance before each test to ensure isolation.
     */
    @BeforeEach
    void setUp() {
        sessionService = new InMemorySessionService();
    }

    /**
     * Verifies that creating a session returns a response with a non-null ID,
     * the correct model name, and turn number 0.
     */
    @Test
    void createSessionReturnsSessionWithCorrectMetadata() {
        // Arrange
        CreateSessionRequest request = new CreateSessionRequest("llama3:latest");
        request.setLanguage("de");

        // Act
        SessionResponse response = sessionService.createSession(request);

        // Assert
        assertNotNull(response.getSessionId());
        assertFalse(response.getSessionId().isBlank());
        assertEquals("llama3:latest", response.getModel());
        assertEquals("de", response.getLanguage());
        assertEquals(0, response.getTurnNumber());
    }

    /**
     * Verifies that a created session can be retrieved by its ID.
     */
    @Test
    void getSessionReturnsPreviouslyCreatedSession() {
        // Arrange
        CreateSessionRequest request = new CreateSessionRequest("llama3:latest");
        SessionResponse created = sessionService.createSession(request);

        // Act
        Optional<SessionResponse> found = sessionService.getSession(created.getSessionId());

        // Assert
        assertTrue(found.isPresent());
        assertEquals(created.getSessionId(), found.get().getSessionId());
    }

    /**
     * Verifies that retrieving an unknown session returns an empty Optional.
     */
    @Test
    void getSessionReturnsEmptyForUnknownId() {
        // Act
        Optional<SessionResponse> result = sessionService.getSession("unknown-session-id");

        // Assert
        assertTrue(result.isEmpty());
    }

    /**
     * Verifies that submitting a turn increments the turn number and returns
     * a turn response for the correct turn.
     */
    @Test
    void submitTurnIncreasesTurnNumber() {
        // Arrange
        CreateSessionRequest createRequest = new CreateSessionRequest("llama3:latest");
        SessionResponse session = sessionService.createSession(createRequest);

        UserActionRequest action = new UserActionRequest();
        action.setType(UserActionRequest.TypeEnum.ACTION);
        action.setContent("I look around the room.");
        TurnRequest turnRequest = new TurnRequest(action);

        // Act
        Optional<TurnResponse> response = sessionService.submitTurn(session.getSessionId(), turnRequest);

        // Assert
        assertTrue(response.isPresent());
        assertEquals(1, response.get().getTurnNumber());
        assertNotNull(response.get().getNarrative());
    }

    /**
     * Verifies that submitting a turn for an unknown session returns an empty Optional.
     */
    @Test
    void submitTurnReturnsEmptyForUnknownSession() {
        // Arrange
        UserActionRequest action = new UserActionRequest();
        action.setType(UserActionRequest.TypeEnum.SPEECH);
        action.setContent("Hello!");
        TurnRequest turnRequest = new TurnRequest(action);

        // Act
        Optional<TurnResponse> response = sessionService.submitTurn("non-existent", turnRequest);

        // Assert
        assertTrue(response.isEmpty());
    }

    /**
     * Verifies that the turn number increments correctly across multiple turns.
     */
    @Test
    void multipleSuccessiveTurnsIncrementTurnNumber() {
        // Arrange
        CreateSessionRequest createRequest = new CreateSessionRequest("llama3:latest");
        SessionResponse session = sessionService.createSession(createRequest);
        String sessionId = session.getSessionId();

        UserActionRequest action = new UserActionRequest();
        action.setType(UserActionRequest.TypeEnum.ACTION);
        action.setContent("Next action.");
        TurnRequest turnRequest = new TurnRequest(action);

        // Act
        sessionService.submitTurn(sessionId, turnRequest);
        Optional<TurnResponse> secondTurn = sessionService.submitTurn(sessionId, turnRequest);

        // Assert
        assertTrue(secondTurn.isPresent());
        assertEquals(2, secondTurn.get().getTurnNumber());
    }

    /**
     * Verifies that the session language defaults to "en" when not specified.
     */
    @Test
    void createSessionUsesDefaultLanguageWhenNotProvided() {
        // Arrange
        CreateSessionRequest request = new CreateSessionRequest("llama3:latest");
        // language intentionally left null

        // Act
        SessionResponse response = sessionService.createSession(request);

        // Assert
        assertEquals("en", response.getLanguage());
    }
}