RpgRoller/RpgRoller.Tests/Services/WorkspaceQueryServiceTests.cs

using Microsoft.AspNetCore.Http;
using RpgRoller.Components;

namespace RpgRoller.Tests;

public sealed class WorkspaceQueryServiceTests
{
    private sealed class StubGameService : IGameService
    {
        public IReadOnlyList<RulesetDefinition> GetRulesets()
        {
            throw new NotSupportedException();
        }

        public ServiceResult<UserSummary> Register(string username, string password, string displayName)
        {
            throw new NotSupportedException();
        }

        public ServiceResult<(UserSummary User, string SessionToken)> Login(string username, string password)
        {
            throw new NotSupportedException();
        }

        public void Logout(string sessionToken)
        {
            throw new NotSupportedException();
        }

        public UserSummary? GetUserBySession(string sessionToken)
        {
            throw new NotSupportedException();
        }

        public ServiceResult<MeResponse> GetMe(string sessionToken)
        {
            return GetMeHandler(sessionToken);
        }

        public ServiceResult<CampaignSummary> CreateCampaign(string sessionToken, string name, string rulesetId)
        {
            throw new NotSupportedException();
        }

        public ServiceResult<IReadOnlyList<CampaignSummary>> GetCampaigns(string sessionToken)
        {
            return GetCampaignsHandler(sessionToken);
        }

        public ServiceResult<IReadOnlyList<CampaignOption>> GetCharacterCampaignOptions(string sessionToken)
        {
            throw new NotSupportedException();
        }

        public ServiceResult<CampaignRoster> GetCampaign(string sessionToken, Guid campaignId)
        {
            throw new NotSupportedException();
        }

        public ServiceResult<bool> DeleteCampaign(string sessionToken, Guid campaignId)
        {
            throw new NotSupportedException();
        }

        public ServiceResult<IReadOnlyList<string>> GetUsernames(string sessionToken)
        {
            throw new NotSupportedException();
        }

        public ServiceResult<IReadOnlyList<AdminUserSummary>> GetUsers(string sessionToken)
        {
            throw new NotSupportedException();
        }

        public ServiceResult<AdminUserSummary> UpdateUserRoles(string sessionToken, Guid userId, IReadOnlyList<string> roles)
        {
            throw new NotSupportedException();
        }

        public ServiceResult<bool> DeleteUser(string sessionToken, Guid userId)
        {
            throw new NotSupportedException();
        }

        public ServiceResult<CharacterSummary> CreateCharacter(string sessionToken, string name, Guid campaignId)
        {
            throw new NotSupportedException();
        }

        public ServiceResult<CharacterSummary> UpdateCharacter(string sessionToken, Guid characterId, string name, Guid? campaignId, string? ownerUsername = null)
        {
            throw new NotSupportedException();
        }

        public ServiceResult<bool> DeleteCharacter(string sessionToken, Guid characterId)
        {
            throw new NotSupportedException();
        }

        public ServiceResult<bool> ActivateCharacter(string sessionToken, Guid characterId)
        {
            throw new NotSupportedException();
        }

        public ServiceResult<IReadOnlyList<CharacterSummary>> GetOwnCharacters(string sessionToken)
        {
            throw new NotSupportedException();
        }

        public ServiceResult<SkillGroupSummary> CreateSkillGroup(string sessionToken, Guid characterId, string name, string diceRollDefinition, int wildDice, bool allowFumble, int? fumbleRange = null)
        {
            throw new NotSupportedException();
        }

        public ServiceResult<SkillGroupSummary> UpdateSkillGroup(string sessionToken, Guid skillGroupId, string name, string diceRollDefinition, int wildDice, bool allowFumble, int? fumbleRange = null)
        {
            throw new NotSupportedException();
        }

        public ServiceResult<bool> DeleteSkillGroup(string sessionToken, Guid skillGroupId)
        {
            throw new NotSupportedException();
        }

        public ServiceResult<SkillSummary> CreateSkill(string sessionToken, Guid characterId, string name, string diceRollDefinition, int wildDice, bool allowFumble, Guid? skillGroupId = null, int? fumbleRange = null, bool rolemasterAutoRetry = false)
        {
            throw new NotSupportedException();
        }

        public ServiceResult<SkillSummary> UpdateSkill(string sessionToken, Guid skillId, string name, string diceRollDefinition, int wildDice, bool allowFumble, Guid? skillGroupId = null, int? fumbleRange = null, bool rolemasterAutoRetry = false)
        {
            throw new NotSupportedException();
        }

        public ServiceResult<bool> DeleteSkill(string sessionToken, Guid skillId)
        {
            throw new NotSupportedException();
        }

        public ServiceResult<CharacterSheet> GetCharacterSheet(string sessionToken, Guid characterId)
        {
            throw new NotSupportedException();
        }

        public ServiceResult<RollResult> RollSkill(string sessionToken, Guid skillId, string visibility, int situationalModifier = 0)
        {
            throw new NotSupportedException();
        }

        public ServiceResult<RollResult> RollCustom(string sessionToken, Guid characterId, string expression, string visibility)
        {
            throw new NotSupportedException();
        }

        public ServiceResult<IReadOnlyList<CampaignLogEntry>> GetCampaignLog(string sessionToken, Guid campaignId)
        {
            throw new NotSupportedException();
        }

        public ServiceResult<CampaignLogPage> GetCampaignLogPage(string sessionToken, Guid campaignId, Guid? afterRollId = null, int? limit = null)
        {
            throw new NotSupportedException();
        }

        public ServiceResult<CampaignRollDetail> GetRollDetail(string sessionToken, Guid rollId)
        {
            throw new NotSupportedException();
        }

        public ServiceResult<CampaignStateSnapshot> GetCampaignStateSnapshot(string sessionToken, Guid campaignId)
        {
            throw new NotSupportedException();
        }

        public Func<string, ServiceResult<MeResponse>> GetMeHandler { get; init; } = _ => ServiceResult<MeResponse>.Failure("unexpected_call", "Unexpected GetMe call.");

        public Func<string, ServiceResult<IReadOnlyList<CampaignSummary>>> GetCampaignsHandler { get; init; } = _ => ServiceResult<IReadOnlyList<CampaignSummary>>.Failure("unexpected_call", "Unexpected GetCampaigns call.");
    }

    [Fact]
    public void SessionTokenAccessor_ReadsSessionCookieFromHttpContext()
    {
        var httpContext = new DefaultHttpContext();
        httpContext.Request.Headers.Cookie = "rpgroller_session=session-token";

        var accessor = new HttpContextAccessor { HttpContext = httpContext };
        var sessionTokenAccessor = new WorkspaceSessionTokenAccessor(accessor);

        Assert.Equal("session-token", sessionTokenAccessor.GetRequiredSessionToken());
    }

    [Fact]
    public async Task GetCampaignsAsync_UsesCapturedSessionToken()
    {
        var service = new StubGameService
        {
            GetCampaignsHandler = sessionToken =>
            {
                Assert.Equal("server-session", sessionToken);
                return ServiceResult<IReadOnlyList<CampaignSummary>>.Success([new(Guid.NewGuid(), "Alpha", "d6", new(Guid.NewGuid(), "GM"), 1)]);
            }
        };

        var queryService = new WorkspaceQueryService(service, CreateSessionTokenAccessor("server-session"));
        var campaigns = await queryService.GetCampaignsAsync();

        Assert.Single(campaigns);
    }

    [Fact]
    public async Task GetMeAsync_MapsUnauthorizedServiceResultToApiRequestException()
    {
        var service = new StubGameService { GetMeHandler = _ => ServiceResult<MeResponse>.Failure("unauthorized", "You must be logged in.") };

        var queryService = new WorkspaceQueryService(service, CreateSessionTokenAccessor("expired-session"));
        var exception = await Assert.ThrowsAsync<ApiRequestException>(queryService.GetMeAsync);

        Assert.Equal(401, exception.StatusCode);
        Assert.Equal("You must be logged in.", exception.Message);
        Assert.Equal("unauthorized", exception.ErrorCode);
    }

    private static WorkspaceSessionTokenAccessor CreateSessionTokenAccessor(string sessionToken)
    {
        var httpContext = new DefaultHttpContext();
        httpContext.Request.Headers.Cookie = $"rpgroller_session={sessionToken}";
        return new(new HttpContextAccessor { HttpContext = httpContext });
    }
}