chapter-organizer/Tests/Printing/NoteTemplateMerger_Tests.cs

using Core.Printing;

namespace Tests.Printing;

[TestFixture]
public class NoteTemplateMerger_Tests
{
    [Test]
    public void Merge_ReplacesKnownTokens()
    {
        var tokens = PrintTokenMap.Create();
        tokens["FirstName"] = "Aria";
        tokens["LastName"] = "Cole";

        var result = NoteTemplateMerger.Merge("Hello {{FirstName}} {{LastName}}", tokens);

        Assert.That(result, Is.EqualTo("Hello Aria Cole"));
    }

    [Test]
    public void Merge_SupportsDottedAndSpacedNames()
    {
        var tokens = PrintTokenMap.Create();
        tokens["Chapter.Name"] = "North TSA";
        tokens["Interview Time"] = "3:20-3:35";

        var result = NoteTemplateMerger.Merge(
            "{{Chapter.Name}} at {{Interview Time}}",
            tokens);

        Assert.That(result, Is.EqualTo("North TSA at 3:20-3:35"));
    }

    [Test]
    public void Merge_IsCaseAndWhitespaceTolerant()
    {
        var tokens = PrintTokenMap.Create();
        tokens["FirstName"] = "Aria";

        var result = NoteTemplateMerger.Merge("{{  firstname  }}", tokens);

        Assert.That(result, Is.EqualTo("Aria"));
    }

    [Test]
    public void Merge_LeavesUnknownTokensInPlace()
    {
        var tokens = PrintTokenMap.Create();
        tokens["FirstName"] = "Aria";

        var result = NoteTemplateMerger.Merge("{{FirstName}} {{Missing}}", tokens);

        Assert.That(result, Is.EqualTo("Aria {{Missing}}"));
    }

    [Test]
    public void Merge_KnownEmptyBecomesBlank()
    {
        var tokens = PrintTokenMap.Create();
        tokens["Interview Time"] = string.Empty;

        var result = NoteTemplateMerger.Merge("Time: {{Interview Time}}.", tokens);

        Assert.That(result, Is.EqualTo("Time: ."));
    }

    [Test]
    public void Merge_EmptyTemplate_IsEmpty()
    {
        Assert.That(NoteTemplateMerger.Merge(null, PrintTokenMap.Create()), Is.EqualTo(string.Empty));
        Assert.That(NoteTemplateMerger.Merge("", PrintTokenMap.Create()), Is.EqualTo(string.Empty));
    }

    [Test]
    public void Merge_PageBreak_IsSentinel()
    {
        var result = NoteTemplateMerger.Merge(
            "Above\n{{PageBreak}}\nBelow",
            PrintTokenMap.Create());

        Assert.That(result, Does.Contain(NoteTemplateMerger.PageBreakSentinel));
        Assert.That(result, Does.Not.Contain("{{PageBreak}}"));
    }

    [Test]
    public void ApplyLayout_ReplacesSentinelAndParagraphWrap()
    {
        var raw = NoteTemplateMerger.ApplyLayout(
            $"x{NoteTemplateMerger.PageBreakSentinel}y");
        var wrapped = NoteTemplateMerger.ApplyLayout(
            $"<p>{NoteTemplateMerger.PageBreakSentinel}</p>");

        Assert.That(raw, Is.EqualTo($"x{NoteTemplateMerger.PageBreakHtml}y"));
        Assert.That(wrapped, Is.EqualTo(NoteTemplateMerger.PageBreakHtml));
    }

    [Test]
    public void Merge_AnswerSpace_IsSentinel()
    {
        var result = NoteTemplateMerger.Merge(
            "Q?\n{{AnswerSpace}}\nNext",
            PrintTokenMap.Create());

        Assert.That(result, Does.Contain(NoteTemplateMerger.AnswerSpaceSentinel));
        Assert.That(result, Does.Not.Contain("{{AnswerSpace}}"));
    }

    [Test]
    public void ApplyLayout_ReplacesAnswerSpaceSentinelAndParagraphWrap()
    {
        var raw = NoteTemplateMerger.ApplyLayout(
            $"x{NoteTemplateMerger.AnswerSpaceSentinel}y");
        var wrapped = NoteTemplateMerger.ApplyLayout(
            $"<p>{NoteTemplateMerger.AnswerSpaceSentinel}</p>");

        Assert.That(raw, Is.EqualTo($"x{NoteTemplateMerger.AnswerSpaceHtml}y"));
        Assert.That(wrapped, Is.EqualTo(NoteTemplateMerger.AnswerSpaceHtml));
    }

    [Test]
    public void Merge_RankedStudents_IsHtmlFragmentSentinel()
    {
        var result = NoteTemplateMerger.Merge(
            "{{Name}}\n{{RankedStudents}}",
            PrintTokenMap.Create());

        Assert.That(result, Does.Contain(NoteTemplateMerger.HtmlFragmentSentinel(NoteTemplateMerger.RankedStudentsToken)));
        Assert.That(result, Does.Not.Contain("{{RankedStudents}}"));
    }

    [Test]
    public void ApplyLayout_ReplacesHtmlFragmentSentinel()
    {
        var sentinel = NoteTemplateMerger.HtmlFragmentSentinel(NoteTemplateMerger.RankedStudentsToken);
        var fragments = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
        {
            [NoteTemplateMerger.RankedStudentsToken] = "<div class=\"print-rank-badges\">Aria</div>"
        };

        var raw = NoteTemplateMerger.ApplyLayout($"x{sentinel}y", fragments);
        var wrapped = NoteTemplateMerger.ApplyLayout($"<p>{sentinel}</p>", fragments);
        var missing = NoteTemplateMerger.ApplyLayout($"x{sentinel}y");

        Assert.That(raw, Is.EqualTo("x<div class=\"print-rank-badges\">Aria</div>y"));
        Assert.That(wrapped, Is.EqualTo("<div class=\"print-rank-badges\">Aria</div>"));
        Assert.That(missing, Is.EqualTo("xy"));
    }

    [Test]
    public void Merge_Legend_IsSentinel()
    {
        var result = NoteTemplateMerger.Merge("{{Legend}}", PrintTokenMap.Create());

        Assert.That(result, Does.Contain(NoteTemplateMerger.LegendSentinel));
        Assert.That(result, Does.Not.Contain("{{Legend}}"));
    }

    [Test]
    public void ApplyLayout_ReplacesLegendSentinel()
    {
        var html = NoteTemplateMerger.ApplyLayout(
            $"<p>{NoteTemplateMerger.LegendSentinel}</p>");

        Assert.That(html, Does.Contain("print-badge-legend"));
        Assert.That(html, Does.Contain(EventAttributeMarks.Individual));
        Assert.That(html, Does.Not.Contain("event-rank-1"));
    }
}