Luna/Luna.Channels.Tests/DependencyInjectionTests.cs

using Luna.Channels.Abstractions;
using Luna.Channels.Tests.Stubs;
using Luna.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Options;

namespace Luna.Channels.Tests;

[TestFixture]
[Category("Unit")]
public class DependencyInjectionTests
{
    private ServiceCollection _services = null!;

    [SetUp]
    public void SetUp()
    {
        _services = new ServiceCollection();
    }

    [Test]
    public void AddChannels_RegistersIChannelManager_AsSingleton()
    {
        _services.AddChannels();
        var provider = _services.BuildServiceProvider();

        var descriptor = _services.FirstOrDefault(d => d.ServiceType == typeof(IChannelManager));

        Assert.That(descriptor, Is.Not.Null);
        Assert.That(descriptor!.Lifetime, Is.EqualTo(ServiceLifetime.Singleton));
    }

    [Test]
    public void AddChannels_IChannelManager_IsResolvableFromContainer()
    {
        _services.AddChannels();
        var provider = _services.BuildServiceProvider();

        var manager = provider.GetService<IChannelManager>();

        Assert.That(manager, Is.Not.Null);
    }

    [Test]
    public void AddChannels_TelegramOptions_IsRegistered()
    {
        _services.AddChannels();
        var provider = _services.BuildServiceProvider();

        var descriptor = _services.FirstOrDefault(d =>
            d.ServiceType.IsGenericType &&
            d.ServiceType.GetGenericTypeDefinition() == typeof(IOptions<>) &&
            d.ServiceType.GetGenericArguments()[0] == typeof(TelegramOptions));

        Assert.That(descriptor, Is.Not.Null,
            "AddChannels() must register TelegramOptions via IOptions<TelegramOptions>");
    }

    [Test]
    public void AddChannels_CliChannel_IsRegistered()
    {
        _services.AddChannels();
        var provider = _services.BuildServiceProvider();

        var channels = provider.GetServices<IChannel>().ToList();
        var channelTypes = channels.Select(c => c.ChannelType).ToList();

        Assert.That(channelTypes, Contains.Item("cli"),
            "AddChannels() must register a CliChannel with ChannelType 'cli'");
    }

    [Test]
    public void AddChannels_TelegramChannel_IsRegistered()
    {
        _services.AddChannels();
        var provider = _services.BuildServiceProvider();

        var channels = provider.GetServices<IChannel>().ToList();
        var channelTypes = channels.Select(c => c.ChannelType).ToList();

        Assert.That(channelTypes, Contains.Item("telegram"),
            "AddChannels() must register a TelegramChannel with ChannelType 'telegram'");
    }

    [Test]
    public void AddChannels_CalledTwice_DoesNotDuplicateSingletonRegistration()
    {
        _services.AddChannels();
        _services.AddChannels();
        var provider = _services.BuildServiceProvider();

        var descriptors = _services.Where(d => d.ServiceType == typeof(IChannelManager)).ToList();

        Assert.That(descriptors, Has.Count.EqualTo(1),
            "Calling AddChannels() twice must not register IChannelManager twice");
    }

    [Test]
    public void AddChannels_SameProviderInstance_ReturnsSameIChannelManager()
    {
        _services.AddChannels();
        var provider = _services.BuildServiceProvider();

        var first = provider.GetRequiredService<IChannelManager>();
        var second = provider.GetRequiredService<IChannelManager>();

        Assert.That(first, Is.SameAs(second),
            "IChannelManager must be registered as Singleton — same instance on every resolve");
    }
}