AyCode.Core/AyCode.Services.Server.Tests/SignalRs/SignalRTestHelper.cs

using AyCode.Core.Extensions;
using AyCode.Services.SignalRs;
using MessagePack;
using MessagePack.Resolvers;

namespace AyCode.Services.Server.Tests.SignalRs;

/// <summary>
/// Helper methods for creating SignalR test messages.
/// Uses the production SignalR types for compatibility with the actual client/server code.
/// </summary>
public static class SignalRTestHelper
{
    private static readonly MessagePackSerializerOptions MessagePackOptions = ContractlessStandardResolver.Options;

    /// <summary>
    /// Creates a MessagePack message for parameters using IdMessage format.
    /// Each parameter is serialized directly as JSON (no array wrapping).
    /// </summary>
    public static byte[] CreatePrimitiveParamsMessage(params object[] values)
    {
        var idMessage = new IdMessage(values);
        var postMessage = new SignalPostJsonDataMessage<IdMessage>(idMessage);
        return MessagePackSerializer.Serialize(postMessage, MessagePackOptions);
    }

    /// <summary>
    /// Creates a MessagePack message for a single primitive parameter.
    /// </summary>
    public static byte[] CreateSinglePrimitiveMessage<T>(T value) where T : notnull
    {
        return CreatePrimitiveParamsMessage(value);
    }

    /// <summary>
    /// Creates a MessagePack message for a complex object parameter.
    /// Uses PostDataJson pattern for single complex objects.
    /// </summary>
    public static byte[] CreateComplexObjectMessage<T>(T obj)
    {
        var json = obj.ToJson();
        var postMessage = new SignalPostJsonDataMessage<object>(json);
        return MessagePackSerializer.Serialize(postMessage, MessagePackOptions);
    }

    /// <summary>
    /// Creates an empty MessagePack message for parameterless methods.
    /// </summary>
    public static byte[] CreateEmptyMessage()
    {
        var postMessage = new SignalPostJsonDataMessage<object>();
        return MessagePackSerializer.Serialize(postMessage, MessagePackOptions);
    }

    /// <summary>
    /// Deserialize a SignalResponseJsonMessage from the captured SentMessage.
    /// </summary>
    public static T? GetResponseData<T>(SentMessage sentMessage)
    {
        if (sentMessage.Message is SignalResponseJsonMessage jsonResponse && jsonResponse.ResponseData != null)
        {
            return jsonResponse.ResponseData.JsonTo<T>();
        }
        
        if (sentMessage.Message is SignalResponseBinaryMessage binaryResponse && binaryResponse.ResponseData != null)
        {
            return binaryResponse.ResponseData.BinaryTo<T>();
        }
        
        return default;
    }

    /// <summary>
    /// Gets the response status from either JSON or Binary message.
    /// </summary>
    private static SignalResponseStatus? GetResponseStatus(ISignalRMessage message)
    {
        return message switch
        {
            SignalResponseJsonMessage jsonMsg => jsonMsg.Status,
            SignalResponseBinaryMessage binaryMsg => binaryMsg.Status,
            _ => null
        };
    }

    /// <summary>
    /// Assert that a response was successful.
    /// </summary>
    public static void AssertSuccessResponse(SentMessage sentMessage, int expectedTag)
    {
        var status = GetResponseStatus(sentMessage.Message);
        if (status == null)
            throw new AssertFailedException($"Response is not a valid SignalR response message. Type: {sentMessage.Message.GetType().Name}");
        
        if (status != SignalResponseStatus.Success)
            throw new AssertFailedException($"Expected Success status but got {status}");
        
        if (sentMessage.MessageTag != expectedTag)
            throw new AssertFailedException($"Expected tag {expectedTag} but got {sentMessage.MessageTag}");
    }

    /// <summary>
    /// Assert that a response was an error.
    /// </summary>
    public static void AssertErrorResponse(SentMessage sentMessage, int expectedTag)
    {
        var status = GetResponseStatus(sentMessage.Message);
        if (status == null)
            throw new AssertFailedException($"Response is not a valid SignalR response message. Type: {sentMessage.Message.GetType().Name}");
        
        if (status != SignalResponseStatus.Error)
            throw new AssertFailedException($"Expected Error status but got {status}");
        
        if (sentMessage.MessageTag != expectedTag)
            throw new AssertFailedException($"Expected tag {expectedTag} but got {sentMessage.MessageTag}");
    }
}