ScadaBridge/tests/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase.Tests/TemplateEngineRepositoryTests.cs

using Microsoft.EntityFrameworkCore;
using ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates;
using ZB.MOM.WW.ScadaBridge.ConfigurationDatabase;
using ZB.MOM.WW.ScadaBridge.ConfigurationDatabase.Repositories;

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

public class TemplateEngineRepositoryTests : IDisposable
{
    private readonly ScadaBridgeDbContext _context;
    private readonly TemplateEngineRepository _repository;

    public TemplateEngineRepositoryTests()
    {
        var options = new DbContextOptionsBuilder<ScadaBridgeDbContext>()
            .UseSqlite("DataSource=:memory:")
            .Options;

        _context = new ScadaBridgeDbContext(options);
        _context.Database.OpenConnection();
        _context.Database.EnsureCreated();
        _repository = new TemplateEngineRepository(_context);
    }

    public void Dispose()
    {
        _context.Database.CloseConnection();
        _context.Dispose();
    }

    [Fact]
    public async Task GetTemplateWithChildrenAsync_ReturnsTemplateWithAllMemberCollectionsPopulated()
    {
        // Arrange: a template with one attribute, one alarm, one script and one composition.
        var composed = new Template("ComposedTemplate");
        _context.Templates.Add(composed);
        await _context.SaveChangesAsync();

        var template = new Template("ParentTemplate");
        template.Attributes.Add(new TemplateAttribute("Attr1"));
        template.Alarms.Add(new TemplateAlarm("Alarm1"));
        template.Scripts.Add(new TemplateScript("Script1", "return 1;"));
        template.Compositions.Add(new TemplateComposition("Slot1") { ComposedTemplateId = composed.Id });
        _context.Templates.Add(template);
        await _context.SaveChangesAsync();

        // Act
        var loaded = await _repository.GetTemplateWithChildrenAsync(template.Id);

        // Assert: the method must deliver the template's child members to the caller,
        // not silently drop them. Regression guard for ConfigurationDatabase-001.
        Assert.NotNull(loaded);
        Assert.Equal(template.Id, loaded!.Id);
        Assert.Single(loaded.Attributes);
        Assert.Equal("Attr1", loaded.Attributes.First().Name);
        Assert.Single(loaded.Alarms);
        Assert.Equal("Alarm1", loaded.Alarms.First().Name);
        Assert.Single(loaded.Scripts);
        Assert.Equal("Script1", loaded.Scripts.First().Name);
        Assert.Single(loaded.Compositions);
        Assert.Equal("Slot1", loaded.Compositions.First().InstanceName);
    }

    [Fact]
    public async Task TemplateScript_ExecutionTimeoutSeconds_RoundTripsThroughEf()
    {
        // M2.5 (#9): the nullable per-script execution timeout must persist and
        // reload through EF — both an explicit value and a null (use-global).
        var template = new Template("TimeoutTemplate");
        template.Scripts.Add(new TemplateScript("WithTimeout", "return 1;")
        {
            ExecutionTimeoutSeconds = 45
        });
        template.Scripts.Add(new TemplateScript("NoTimeout", "return 2;")); // null
        _context.Templates.Add(template);
        await _context.SaveChangesAsync();

        // Detach so the reload comes from the store, not the change tracker.
        _context.ChangeTracker.Clear();

        var loaded = await _context.Templates
            .Include(t => t.Scripts)
            .SingleAsync(t => t.Name == "TimeoutTemplate");

        var withTimeout = loaded.Scripts.Single(s => s.Name == "WithTimeout");
        Assert.Equal(45, withTimeout.ExecutionTimeoutSeconds);

        var noTimeout = loaded.Scripts.Single(s => s.Name == "NoTimeout");
        Assert.Null(noTimeout.ExecutionTimeoutSeconds);
    }

    [Fact]
    public async Task GetTemplateWithChildrenAsync_ReturnsNull_WhenTemplateDoesNotExist()
    {
        var loaded = await _repository.GetTemplateWithChildrenAsync(9999);

        Assert.Null(loaded);
    }

    [Fact]
    public async Task GetTemplatesWithChildrenAsync_BulkVariant_FetchesEveryMatchingNameInOneQuery()
    {
        // Transport-008 regression: BundleImporter.PreviewAsync previously
        // called GetTemplateWithChildrenAsync(stub.Id) per matching template
        // name. The bulk variant returns every match in a single query.
        var a = new Template("Alpha");
        a.Attributes.Add(new TemplateAttribute("A1"));
        a.Scripts.Add(new TemplateScript("AS1", "return 1;"));
        var b = new Template("Beta");
        b.Alarms.Add(new TemplateAlarm("BAlarm"));
        var c = new Template("Gamma");
        _context.Templates.AddRange(a, b, c);
        await _context.SaveChangesAsync();

        var result = await _repository.GetTemplatesWithChildrenAsync(new[] { "Alpha", "Beta", "DoesNotExist" });

        Assert.Equal(2, result.Count);
        var loadedA = Assert.Single(result, t => t.Name == "Alpha");
        var loadedB = Assert.Single(result, t => t.Name == "Beta");
        Assert.Single(loadedA.Attributes);
        Assert.Equal("A1", loadedA.Attributes.First().Name);
        Assert.Single(loadedA.Scripts);
        Assert.Single(loadedB.Alarms);
        Assert.Equal("BAlarm", loadedB.Alarms.First().Name);
        Assert.DoesNotContain(result, t => t.Name == "Gamma");
    }

    [Fact]
    public async Task GetTemplatesWithChildrenAsync_EmptyNames_ReturnsEmpty()
    {
        var result = await _repository.GetTemplatesWithChildrenAsync(Array.Empty<string>());

        Assert.Empty(result);
    }

    [Fact]
    public async Task GetTemplatesWithChildrenAsync_NullEnumerable_ReturnsEmpty()
    {
        var result = await _repository.GetTemplatesWithChildrenAsync(null!);

        Assert.Empty(result);
    }

    [Fact]
    public async Task GetTemplatesWithChildrenAsync_FiltersOutDuplicatesAndEmptyStrings()
    {
        var a = new Template("Alpha");
        _context.Templates.Add(a);
        await _context.SaveChangesAsync();

        // Duplicate names + empty / null entries should not throw; the helper
        // deduplicates and filters them out before the SQL IN clause.
        var result = await _repository.GetTemplatesWithChildrenAsync(
            new[] { "Alpha", "Alpha", "", null!, "Alpha" });

        Assert.Single(result);
        Assert.Equal("Alpha", result[0].Name);
    }

    [Fact]
    public async Task GetTemplateWithChildrenAsync_PreservesParentTemplateId_ForInheritanceChainWalk()
    {
        // FlatteningPipeline.BuildTemplateChainAsync walks ParentTemplateId upward.
        // The result of GetTemplateWithChildrenAsync must carry that link intact.
        var baseTemplate = new Template("BaseTemplate");
        _context.Templates.Add(baseTemplate);
        await _context.SaveChangesAsync();

        var derived = new Template("DerivedTemplate") { ParentTemplateId = baseTemplate.Id };
        _context.Templates.Add(derived);
        await _context.SaveChangesAsync();

        var loaded = await _repository.GetTemplateWithChildrenAsync(derived.Id);

        Assert.NotNull(loaded);
        Assert.Equal(baseTemplate.Id, loaded!.ParentTemplateId);
    }

    [Fact]
    public async Task AddAndGetNativeAlarmSourcesByTemplateId_RoundTrips()
    {
        var t = new Template("T");
        _context.Templates.Add(t);
        await _context.SaveChangesAsync();

        await _repository.AddTemplateNativeAlarmSourceAsync(
            new TemplateNativeAlarmSource("S") { TemplateId = t.Id, ConnectionName = "C", SourceReference = "r" });
        await _context.SaveChangesAsync();

        var list = await _repository.GetNativeAlarmSourcesByTemplateIdAsync(t.Id);
        Assert.Single(list);
        Assert.Equal("S", list[0].Name);
    }

    [Fact]
    public async Task GetTemplateWithChildren_IncludesNativeAlarmSources()
    {
        var t = new Template("T");
        t.NativeAlarmSources.Add(new TemplateNativeAlarmSource("S") { ConnectionName = "C", SourceReference = "r" });
        _context.Templates.Add(t);
        await _context.SaveChangesAsync();

        var loaded = await _repository.GetTemplateWithChildrenAsync(t.Id);
        Assert.Single(loaded!.NativeAlarmSources);
    }
}