Luna/Luna.Channels.Tests/CliChannelTests.cs

using Luna.Channels.Abstractions;
using Luna.Channels.Cli;
using Luna.Channels.Tests.Stubs;
using Luna.Core.Abstractions;
using Luna.Shared;
using Moq;

namespace Luna.Channels.Tests;

[TestFixture]
[Category("Unit")]
public class CliChannelTests
{
    [Test]
    public void ChannelType_Returns_Cli()
    {
        var hubMock = new Mock<IChatHubContext>();
        var channel = new CliChannel("test-1", hubMock.Object);

        Assert.That(channel.ChannelType, Is.EqualTo("cli"));
    }

    [Test]
    public void ChannelId_IsUnique_PerInstance()
    {
        var hubMock = new Mock<IChatHubContext>();
        var channel1 = new CliChannel("test-1", hubMock.Object);
        var channel2 = new CliChannel("test-2", hubMock.Object);

        Assert.That(channel1.ChannelId, Is.Not.EqualTo(channel2.ChannelId));
    }

    [Test]
    public void DisplayName_Returns_HumanReadable()
    {
        var hubMock = new Mock<IChatHubContext>();
        var channel = new CliChannel("test-1", hubMock.Object);

        Assert.That(channel.DisplayName, Is.Not.Null.And.Not.Empty);
    }

    [Test]
    public async Task SendMessageAsync_Sends_ChannelMessage()
    {
        var hubMock = new Mock<IChatHubContext>();
        var channel = new CliChannel("test-1", hubMock.Object);
        var message = new ChannelMessage(
            Guid.NewGuid().ToString(),
            Guid.NewGuid().ToString(),
            "cli-user-1",
            "CLI User",
            "Hello from CLI",
            DateTimeOffset.UtcNow);

        await channel.SendMessageAsync(message);
    }

    [Test]
    public async Task SendStreamingMessageAsync_Consumes_Stream()
    {
        var hubMock = new Mock<IChatHubContext>();
        var channel = new CliChannel("test-1", hubMock.Object);

        async IAsyncEnumerable<ChatStreamUpdate> TestStream()
        {
            yield return new ChatStreamUpdate(ChatStreamUpdateType.Text, "Hello", "assistant", false);
            yield return new ChatStreamUpdate(ChatStreamUpdateType.Text, " world", "assistant", false);
            yield return new ChatStreamUpdate(ChatStreamUpdateType.Complete, null, "assistant", true);
            await Task.CompletedTask;
        }

        await channel.SendStreamingMessageAsync(TestStream());
    }

    [Test]
    public void Dispose_CleansUp()
    {
        var hubMock = new Mock<IChatHubContext>();
        var channel = new CliChannel("test-1", hubMock.Object);

        Assert.That(() => channel.Dispose(), Throws.Nothing);
    }

    [Test]
    public void MessageReceived_Event_Fires_On_RaiseMessageReceived()
    {
        var hubMock = new Mock<IChatHubContext>();
        var channel = new CliChannel("test-1", hubMock.Object);
        ChannelMessageReceivedEventArgs? capturedArgs = null;

        channel.MessageReceived += (_, args) =>
        {
            capturedArgs = args;
            return Task.CompletedTask;
        };

        var message = new ChannelMessage(
            Guid.NewGuid().ToString(),
            Guid.NewGuid().ToString(),
            "cli-user-1",
            "CLI User",
            "Hello from CLI",
            DateTimeOffset.UtcNow);

        channel.RaiseMessageReceived(null, message);

        Assert.That(capturedArgs, Is.Not.Null,
            "MessageReceived event must fire when RaiseMessageReceived is called.");
        Assert.That(capturedArgs!.Message.Content, Is.EqualTo("Hello from CLI"));
    }
}