ScadaBridge/tests/ZB.MOM.WW.ScadaBridge.CentralUI.Tests/Shared/TemplateFolderTreeRevealKeysTests.cs

using Bunit;
using ZB.MOM.WW.ScadaBridge.CentralUI.Components.Shared;
using ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates;

namespace ZB.MOM.WW.ScadaBridge.CentralUI.Tests.Shared;

/// <summary>
/// Covers the additive <c>RevealKeys</c> parameter: the tree opens the ancestors of
/// a caller-named node when no filter is active, and an active filter still wins.
/// </summary>
public class TemplateFolderTreeRevealKeysTests : BunitContext
{
    /// <summary>Initializes a new instance of the <c>TemplateFolderTreeRevealKeysTests</c> class.</summary>
    public TemplateFolderTreeRevealKeysTests()
    {
        JSInterop.Mode = JSRuntimeMode.Loose;
    }

    private static (List<TemplateFolder> folders, List<Template> templates) Catalogue()
    {
        var a = new TemplateFolder("A") { Id = 1 };
        var b = new TemplateFolder("B") { Id = 2, ParentFolderId = 1 };
        var other = new TemplateFolder("Other") { Id = 3 };
        var t7 = new Template("Deep") { Id = 7, FolderId = 2 };
        var t8 = new Template("Elsewhere") { Id = 8, FolderId = 3 };
        return (new() { a, b, other }, new() { t7, t8 });
    }

    /// <summary>Verifies that a change to extra node metadata rebuilds the forest and survives filtering.</summary>
    /// <returns>The result.</returns>
    [Fact]
    public void ExtraNodeMetadataChange_RebuildsAndSurvivesFiltering()
    {
        var template = new Template("Template") { Id = 1 };
        var inherited = false;
        IReadOnlyList<TemplateTreeNode> Children(Template _) => [new()
        {
            Kind = TemplateTreeNodeKind.Composition, Id = 2, Name = "Slot",
            IsInherited = inherited, KeyOverride = inherited ? "inherited:2" : "local:2"
        }];
        var cut = Render<TemplateFolderTree>(p => p.Add(x => x.Templates, new[] { template })
            .Add(x => x.ExtraTemplateChildren, Children).Add(x => x.Filter, "Slot"));
        inherited = true;
        cut.Render(p => p.Add(x => x.Filter, "Slot"));
        var roots = cut.FindComponent<TreeView<TemplateTreeNode>>().Instance.Items;
        var node = Assert.Single(Assert.Single(roots).Children);
        Assert.True(node.IsInherited);
        Assert.Equal("inherited:2", node.Key);
    }

    /// <summary>Verifies that repeated parameters preserve the forest while an in-place rename rebuilds it.</summary>
    /// <returns>The result.</returns>
    [Fact]
    public void RepeatedParameters_PreserveForest_ButInPlaceRenameRebuilds()
    {
        var (folders, templates) = Catalogue();
        var cut = Render<TemplateFolderTree>(p => p.Add(x => x.Folders, folders).Add(x => x.Templates, templates));
        var field = typeof(TemplateFolderTree).GetField("_allRoots", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic)!;
        var first = field.GetValue(cut.Instance);
        cut.Render(p => p.Add(x => x.Folders, folders).Add(x => x.Templates, templates));
        Assert.Same(first, field.GetValue(cut.Instance));
        folders[0].Name = "Renamed";
        cut.Render(p => p.Add(x => x.Folders, folders).Add(x => x.Templates, templates));
        Assert.NotSame(first, field.GetValue(cut.Instance));
        Assert.Contains("Renamed", cut.Markup);
    }

    /// <summary>Verifies that all folders start collapsed when no reveal keys are given.</summary>
    /// <returns>The result.</returns>
    [Fact]
    public void WithoutRevealKeys_AllFoldersStartCollapsed()
    {
        var (f, t) = Catalogue();
        var cut = Render<TemplateFolderTree>(p => p.Add(x => x.Folders, f).Add(x => x.Templates, t));
        Assert.DoesNotContain("Deep", cut.Markup);
        Assert.DoesNotContain("Elsewhere", cut.Markup);
    }

    /// <summary>Verifies that reveal keys expand only the ancestors of the listed template.</summary>
    /// <returns>The result.</returns>
    [Fact]
    public void RevealKeys_ExpandsOnlyTheAncestorsOfTheListedTemplate()
    {
        var (f, t) = Catalogue();
        var cut = Render<TemplateFolderTree>(p => p
            .Add(x => x.Folders, f).Add(x => x.Templates, t)
            .Add(x => x.RevealKeys, (IReadOnlyCollection<string>)new[] { "t:7" }));
        Assert.Contains("Deep", cut.Markup);           // A → B expanded
        Assert.DoesNotContain("Elsewhere", cut.Markup); // Other untouched
    }

    /// <summary>Verifies that an active filter wins over reveal keys.</summary>
    /// <returns>The result.</returns>
    [Fact]
    public void ActiveFilter_WinsOverRevealKeys()
    {
        var (f, t) = Catalogue();
        var cut = Render<TemplateFolderTree>(p => p
            .Add(x => x.Folders, f).Add(x => x.Templates, t)
            .Add(x => x.RevealKeys, (IReadOnlyCollection<string>)new[] { "t:7" })
            .Add(x => x.Filter, "Elsewhere"));
        Assert.Contains("Elsewhere", cut.Markup);
        Assert.DoesNotContain("Deep", cut.Markup);
    }
}