ScadaBridge/tests/ZB.MOM.WW.ScadaBridge.SiteEventLogging.Tests/ServiceWiringTests.cs

using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using ZB.MOM.WW.LocalDb;

namespace ZB.MOM.WW.ScadaBridge.SiteEventLogging.Tests;

/// <summary>
/// Regression tests: the purge and query services must not
/// downcast an injected <see cref="ISiteEventLogger"/> to the concrete type. They now
/// depend on the concrete <see cref="SiteEventLogger"/> directly, and DI must resolve
/// the recorder, query service, and purge service to a single shared instance.
/// </summary>
public class ServiceWiringTests : IDisposable
{
    private readonly string _dbPath;
    private ServiceProvider? _provider;

    /// <summary>Initializes the test class with a service provider backed by a temporary database.</summary>
    public ServiceWiringTests()
    {
        _dbPath = Path.Combine(Path.GetTempPath(), $"test_wiring_{Guid.NewGuid()}.db");
    }

    /// <summary>Releases the resources held by this test class.</summary>
    public void Dispose()
    {
        _provider?.Dispose();
        TestLocalDb.DeleteFiles(_dbPath);
    }

    /// <summary>Verifies that registering site event logging resolves all services and shares one recorder instance.</summary>
    [Fact]
    public void AddSiteEventLogging_ResolvesAllServices_SharingOneRecorderInstance()
    {
        var services = new ServiceCollection();
        services.AddLogging();
        services.Configure<SiteEventLogOptions>(o => o.DatabasePath = _dbPath);
        // SiteEventLogger now takes ILocalDb, so the consolidated site database has to
        // be in the graph for AddSiteEventLogging to resolve at all. In the host this
        // comes from SiteServiceRegistration's AddZbLocalDb.
        services.AddZbLocalDb(new ConfigurationBuilder()
            .AddInMemoryCollection(new Dictionary<string, string?>
            {
                ["LocalDb:Path"] = _dbPath,
            })
            .Build());
        services.AddSiteEventLogging();

        _provider = services.BuildServiceProvider();

        var recorderViaInterface = _provider.GetRequiredService<ISiteEventLogger>();
        var recorderConcrete = _provider.GetRequiredService<SiteEventLogger>();
        var queryService = _provider.GetRequiredService<IEventLogQueryService>();

        // The interface registration must forward to the concrete singleton — purge
        // and query depend on that same instance, so all three share one connection.
        Assert.Same(recorderConcrete, recorderViaInterface);
        Assert.NotNull(queryService);

        // The hosted purge service must also resolve without an InvalidCastException.
        var hosted = _provider.GetServices<Microsoft.Extensions.Hosting.IHostedService>();
        Assert.Contains(hosted, h => h is EventLogPurgeService);
    }

    /// <summary>Verifies that the purge and query services accept the concrete recorder without downcasting.</summary>
    [Fact]
    public void PurgeAndQueryServices_AcceptConcreteRecorder_WithoutDowncast()
    {
        // The services no longer take ISiteEventLogger and downcast it; they take the
        // concrete SiteEventLogger. Constructing them directly must compile and work.
        var options = Options.Create(new SiteEventLogOptions { DatabasePath = _dbPath });
        using var loggerFactory = LoggerFactory.Create(_ => { });
        using var localDb = TestLocalDb.Create(_dbPath);
        using var recorder = new SiteEventLogger(
            options, loggerFactory.CreateLogger<SiteEventLogger>(), localDb.Db);

        var purge = new EventLogPurgeService(
            recorder, options, loggerFactory.CreateLogger<EventLogPurgeService>());
        var query = new EventLogQueryService(
            recorder, options, loggerFactory.CreateLogger<EventLogQueryService>());

        Assert.NotNull(purge);
        Assert.NotNull(query);
    }
}